Original: Distributed Adversarial Training to Robustify Deep Neural Networks at Scale
Revised: Distributed Adversarial Training to Robustify Deep Neural Networks at Scale

Original: Abstract
Revised: Abstract

Original: Current deep neural networks (DNNs) are vulnerable to adversarial attacks, where adversarial perturbations to the inputs can change or manipulate classification.
Revised: Current deep neural networks (DNNs) are vulnerable to adversarial attacks, where adversarial perturbations to the inputs can change or manipulate classiﬁcation.

Original: To defend against such attacks, an effective and popular approach, known as adversarial training (AT) , has been shown to mitigate the negative impact of adversarial attacks by virtue of a min-max robust training method.
Revised: To defend against such attacks, an effective and popular approach, known as adversarial training (AT) , has been shown to mitigate the negative impact of adversarial attacks by virtue of a min-max robust training method.

Original: While effective, it remains unclear whether it can successfully be adapted to the distributed learning context.
Revised: While effective, it remains unclear whether it can successfully be adapted to the distributed learning context.

Original: The power of distributed optimization over multiple machines enables us to scale up robust training over large models and datasets.
Revised: The power of distributed optimization over multiple machines enables us to scale up robust training over large models and datasets.

Original: Spurred by that, we propose distributed adversarial training (DAT) , a large-batch adversarial training framework implemented over multiple machines.
Revised: Spurred by that, we propose distributed adversarial training (DAT) , a large-batch adversarial training framework implemented over multiple machines.

Original: We show that DAT is general, which supports training over labeled and unlabeled data, multiple types of attack generation methods, and gradient compression operations favored for distributed optimization.
Revised: We show that DAT is general, which supports training over labeled and unlabeled data, multiple types of attack generation methods, and gradient compression operations favored for distributed optimization.

Original: Theoretically, we provide, under standard conditions in the optimization theory, the convergence rate of DAT to the first-order stationary points in general non-convex settings.
Revised: Theoretically, we provide, under standard conditions in the optimization theory, the convergence rate of DAT to the ﬁrst-order stationary points in general non-convex settings.

Original: Empirically, we demonstrate that DAT either matches or outperforms state-of-the-art robust accuracies and achieves a graceful training speedup (e.g., on
Revised: Empirically, we demonstrate that DAT either matches or outperforms state-of-the-art robust accuracies and achieves a graceful training speedup (e.g., on

Original: ResNet–50 under ImageNet).
Revised: ResNet–50 under ImageNet).

Original: Codes are available at https://github.com/dat-2022/dat .
Revised: Codes are available at https://github.com/dat-2022/dat .

Original:  INTRODUCTION
Revised:  INTRODUCTION

Original: The rapid increase of research in DNNs and their adoption in practice is, in part, owed to the significant breakthroughs made with DNNs in computer vision
Revised: The rapid increase of research in DNNs and their adoption in practice is, in part, owed to the signiﬁcant breakthroughs made with DNNs in computer vision

Original: [Alom et al., 2018].
Revised: [Alom et al., 2018].

Original: Yet, with the apparent power of DNNs, there remains a serious weakness of robustness.
Revised: Yet, with the apparent power of DNNs, there remains a serious weakness of robustness.

Original: That is, DNNs can easily be manipulated (by an adversary) to output drastically different classifications and can be done so in a controlled and directed way.
Revised: That is, DNNs can easily be manipulated (by an adversary) to output drastically different classiﬁcations and can be done so in a controlled and directed way.

Original: This process is known as an adversarial attack and considered as one of the major hurdles in using DNNs in security critical and real-world applications
Revised: This process is known as an adversarial attack and considered as one of the major hurdles in using DNNs in security critical and real-world applications

Original: [Goodfellow et al., 2015, Szegedy et al., 2013, Carlini and Wagner, 2017,
Revised: [Goodfellow et al., 2015, Szegedy et al., 2013, Carlini and Wagner, 2017,

Original: Papernot et al., 2016, Kurakin et al., 2016,Eykholt et al., 2018, Xu et al., 2019b].
Revised: Papernot et al., 2016, Kurakin et al., 2016, Xu et al., 2019b].

Original: Methods to train DNNs being robust against adversarial attacks are now a major focus in research [Xu et al., 2019a].
Revised: Methods to train DNNs being robust against adversarial attacks are now a major focus in research [Xu et al., 2019a].

Original: But most of them are far from satisfactory [Athalye et al., 2018] with the exception of the adversarial training (AT) approach [Madry et al., 2017].
Revised: But most of them are far from satisfactory [Athalye et al., 2018] with the exception of the adversarial training (AT) approach [Madry et al., 2017].

Original: AT is a min-max robust training method that minimizes the worst-case training loss at adversarially perturbed examples.
Revised: AT is a min-max robust training method that minimizes the worst-case training loss at adversarially perturbed examples.

Original: AT has inspired a wide range of state-of-the-art defenses [Zhang et al., 2019b, Sinha et al., 2018, Boopathy et al., 2020, Carmon et al., 2019,
Revised: AT has inspired a wide range of state-of-the-art defenses [Zhang et al., 2019b, Sinha et al., 2018, Boopathy et al., 2020, Carmon et al., 2019,

Original: Shafahi et al., 2019, Zhang et al., 2019a], which ultimately resort to min-max optimization.
Revised: Shafahi et al., 2019, Zhang et al., 2019a], which ultimately resort to min-max optimization.

Original: However, different from standard training, AT is more computationally intensive and is difficult to scale.
Revised: However, different from standard training, AT is more computationally intensive and is difﬁcult to scale.

Original: Motivation and challenges.
Revised: Motivation and challenges.

Original: First , although a ‘fast’ version of AT (we call Fast AT) was developed in [Wong et al., 2020] where an iterative inner maximization solver is replaced by a simplified (single-step) solution, it may suffer several problems compared to AT: unstable robust learning performance [Li et al., 2020], over-sensitive to learning rate schedule [Rice et al., 2020], and catastrophic forgetting of robustness against strong attacks [Andriushchenko and
Revised: First , although a ‘fast’ version of AT (we call Fast AT) was developed in [Wong et al., 2020] where an iterative inner maximization solver is replaced by a simpliﬁed (single-step) solution, it may suffer several problems compared to AT: unstable robust learning performance [Li et al., 2020], over-sensitive to learning rate schedule [Rice et al., 2020], and catastrophic forgetting of robustness against strong attacks [Andriushchenko and

Original: Flammarion, 2020].
Revised: Flammarion, 2020].

Original: As a result, AT is still the dominant robust training protocol across applications.
Revised: As a result, AT is still the dominant robust training protocol across applications.

Original: Spurred by that, we propose DAT, a new approach to speed up AT by allowing for scaling batch size with distributed machines.
Revised: Spurred by that, we propose DAT, a new approach to speed up AT by allowing for scaling batch size with distributed machines.

Original: Second , existing AT-type methods are generally built on centralized optimization.
Revised: Second , existing AT-type methods are generally built on centralized optimization.

Original: The need of AT in a distributed setting arises when centralized robust training becomes infeasible or ineffective.
Revised: The need of AT in a distributed setting arises when centralized robust training becomes infeasible or ineffective.

Original: For example, training data are distributed as they cannot centrally be stored at a single machine due to their size or privacy.
Revised: For example, training data are distributed as they cannot centrally be stored at a single machine due to their size or privacy.

Original: Or computing units are distributed as they allow large-batch optimization to improve the scalability of training.
Revised: Or computing units are distributed as they allow large-batch optimization to improve the scalability of training.

Original: [Figure] While designing a distributed solution is important, doing so effectively is non-trivial.
Revised: While designing a distributed solution is important, doing so effectively is non-trivial.

Original: Figure 1 demonstrates an example: When scaling batch size with the number of computing nodes, the conventional AT method yields a large performance drop in both robust and standard accuracies.
Revised: Figure 1 demonstrates an example: When scaling batch size with the number of computing nodes, the conventional AT method yields a large performance drop in both robust and standard accuracies.

Original: Thus, the adaptation of AT to distributed learning leaves many unanswered questions.
Revised: Thus, the adaptation of AT to distributed learning leaves many unanswered questions.

Original: In this work, we aim to design a principled and theoretically-grounded (large-batch) DAT framework by making full use of the computing capability of multiple data-locality (distributed) machines, and show that DAT expands the capacity of data storage and the computational scalability.
Revised: In this work, we aim to design a principled and theoretically-grounded (large-batch) DAT framework by making full use of the computing capability of multiple data-locality (distributed) machines, and show that DAT expands the capacity of data storage and the computational scalability.

Original: Furthermore, due to the existence of many variants of AT, it requires a careful and systematic study on distributed AT in its formulation, methodology, theory and performance evaluation.
Revised: Furthermore, due to the existence of many variants of AT, it requires a careful and systematic study on distributed AT in its formulation, methodology, theory and performance evaluation.

Original: Contributions.
Revised: Contributions.

Original: We list our main contributions below.
Revised: We list our main contributions below.

Original: (i)
Revised: (i)

Original: We provide a general algorithmic framework for DAT, which supports multiple (large-batch) distributed variants of AT, e.g., supervised AT and semi-supervised AT.
Revised: We provide a general algorithmic framework for DAT, which supports multiple (large-batch) distributed variants of AT, e.g., supervised AT and semi-supervised AT.

Original: (ii)
Revised: (ii)

Original: In theory, we quantify how descent errors from multiple sources (gradient estimation, quantization, adaptive learning rate, and inner maximization oracle) affect the convergence of DAT.
Revised: In theory, we quantify how descent errors from multiple sources (gradient estimation, quantization, adaptive learning rate, and inner maximization oracle) affect the convergence of DAT.

Original: We prove that the convergence speed of DAT to the first-order stationary points in general non-convex settings at a rate of O (1 / √ T) , where T is the total numberof iterations.
Revised: We prove that the convergence speed of DAT to the ﬁrst-order stationary points in general non-convex settings at a rate of O (1 / p T , where T is the total number

Original:  This result matches the standard convergence rate of classic training algorithms, e.g., stochastic gradient descent (SGD), for only the minimization problems.
Revised: of iterations. This result matches the standard convergence rate of classic training algorithms, e.g., stochastic gradient descent (SGD), for only the minimization problems.

Original: (iii)
Revised: (iii)

Original: In practice, we make a comprehensive empirical study on DAT, showing its effectiveness to ( 1) robust training over ImageNet, (2) provably robust training by randomized smoothing, (3) robust training with unlabeled data, (4) robust pretraining + finetuning, and (5) robust training across different computing and communication configurations.
Revised: In practice, we make a comprehensive empirical study on DAT, showing its effectiveness to (1) robust training over ImageNet, (2) provably robust training by randomized smoothing, (3) robust training with unlabeled data, (4) robust pretraining + ﬁnetuning, and (5) robust training across different computing and communication conﬁgurations.

Original:  RELATED WORK
Revised:  RELATED WORK

Original: Training robust classifiers.
Revised: Training robust classiﬁers.

Original: AT [Madry et al., 2017], the first known min-max optimization-based defense, has inspired a wide range of other effective defenses.
Revised: AT [Madry et al., 2017], the ﬁrst known min-max optimization-based defense, has inspired a wide range of other effective defenses.

Original: Examples include adversarial logit pairing
Revised: Examples include adversarial logit pairing

Original: [Kannan et al., 2018], input gradient or curvature regularization
Revised: [Kannan et al., 2018], input gradient or curvature regularization

Original: [Ross and Doshi-Velez, 2018, Moosavi-Dezfooli et al., 2019], trade-off between robustness and accuracy (TRADES)
Revised: [Ross and Doshi-Velez, 2018, Moosavi-Dezfooli et al., 2019], trade-off between robustness and accuracy (TRADES)

Original: [Zhang et al., 2019b], distributionally robust training [Sinha et al., 2018], dynamic adversarial training [Wang et al., 2019b], robust input attribution regularization
Revised: [Zhang et al., 2019b], distributionally robust training [Sinha et al., 2018], dynamic adversarial training [Wang et al., 2019b], robust input attribution regularization

Original: [Boopathy et al., 2020], certifiably robust training [Wong and Kolter, 2017], and semi-supervised robust training [Stanforth et al., 2019, Carmon et al., 2019].
Revised: [Boopathy et al., 2020], certiﬁably robust training [Wong and Kolter, 2017], and semi-supervised robust training [Stanforth et al., 2019, Carmon et al., 2019].

Original: In particular, some recent works proposed fast but approximate AT algorithms, such as ‘free’ AT [Shafahi et al., 2019], you only propagate once (YOPO)
Revised: In particular, some recent works proposed fast but approximate AT algorithms, such as ‘free’ AT [Shafahi et al., 2019], you only propagate once (YOPO)

Original: [Zhang et al., 2019a], and fast gradient sign method (FGSM) based AT [Wong et al., 2020].
Revised: [Zhang et al., 2019a], and fast gradient sign method (FGSM) based AT [Wong et al., 2020].

Original: These algorithms achieve speedup in training by simplifying the inner maximization step of AT, but are designed for centralized model training.
Revised: These algorithms achieve speedup in training by simplifying the inner maximization step of AT, but are designed for centralized model training.

Original: A few works made empirical efforts to scale AT up by using multiple computing nodes [Xie et al., 2019, Kang et al., 2019, Qin et al., 2019], they were limited to specific use cases and lacked a thorough study on when and how distributed learning helps, either in theory or in practice.
Revised: A few works made empirical efforts to scale AT up by using multiple computing nodes [Xie et al., 2019, Kang et al., 2019, Qin et al., 2019], they were limited to speciﬁc use cases and lacked a thorough study on when and how distributed learning helps, either in theory or in practice.

Original: Distributed model training.
Revised: Distributed model training.

Original: Distributed optimization has been found to be effective for the standard training of machine learning models [Dean et al., 2012, Goyal et al., 2017,
Revised: Distributed optimization has been found to be effective for the standard training of machine learning models [Dean et al., 2012, Goyal et al., 2017,

Original: You et al., 2019, Chen et al., 2020].
Revised: You et al., 2019, Chen et al., 2020].

Original: In contrast to centralized optimization, distributed learning enables increasing the batch size proportional to the number of computing nodes/machines.
Revised: In contrast to centralized optimization, distributed learning enables increasing the batch size proportional to the number of computing nodes/machines.

Original: However, it is challenging to train a model via large-batch optimization without incurring accuracy loss compared to the standard training with same number of epochs [Krizhevsky, 2014, Keskar et al., 2016].
Revised: However, it is challenging to train a model via large-batch optimization without incurring accuracy loss compared to the standard training with same number of epochs [Krizhevsky, 2014, Keskar et al., 2017].

Original: To tackle this challenge, it was shown in [You et al., 2017b, 2018, 2019] that adaptation of learning rates to the increase of the batch size is an essential mean to boost the performance of large-batch optimization.
Revised: To tackle this challenge, it was shown in [You et al., 2017b, 2018, 2019] that adaptation of learning rates to the increase of the batch size is an essential mean to boost the performance of large-batch optimization.

Original: A layer-wise adaptive learning rate strategy was then proposed to speed up the training as well as preserve the accuracy.
Revised: A layer-wise adaptive learning rate strategy was then proposed to speed up the training as well as preserve the accuracy.

Original: Although these works have witnessed several successful applications of distributed learning in training standard image classifiers, they leave the question of how to build robust DNNs with DAT open.
Revised: Although these works have witnessed several successful applications of distributed learning in training standard image classiﬁers, they leave the question of how to build robust DNNs with DAT open.

Original: In this paper, we show that the power of layer-wise adaptive learning rate also applies to DAT.
Revised: In this paper, we show that the power of layer-wise adaptive learning rate also applies to DAT.

Original: Since distributed learning introduces machine-machine communication overhead, another line of work [Alistarh et al., 2017, Yu et al., 2019,
Revised: Since distributed learning introduces machine-machine communication overhead, another line of work [Alistarh et al., 2017, Yu et al., 2019,

Original: Bernstein et al., 2018, Wangni et al., 2018, Stich et al., 2018,
Revised: Bernstein et al., 2018, Wangni et al., 2018, Stich et al., 2018,

Original: Wang et al., 2019a] focused on the design of communication- efficient distributed optimization algorithms.
Revised: Wang et al., 2019a] focused on the design of communicationefﬁcient distributed optimization algorithms.

Original: The study on distributed learning is extensive, but the problem of distributed min-max optimization is less explored, with some exceptions [Srivastava et al., 2011, Notarnicola et al., 2018,Hanada et al., 2017, Tsaknakis et al., 2020, Liu et al., 2019a,b].
Revised: The study on distributed learning is extensive, but the prob- lem of distributed min-max optimization is less explored, with some exceptions [Srivastava et al., 2011, Notarnicola et al., 2018, Tsaknakis et al., 2020, Liu et al., 2019a,b].

Original: A key difference to our work is that none of the aforementioned literature studied the large-batch minmax optimization with its applications to training robust DNNs, neither theoretically nor empirically.
Revised: A key difference to our work is that none of the aforementioned literature studied the large-batch min-max optimization with its applications to training robust DNNs, neither theoretically nor empirically.

Original: While there are recent proposed algorithms for training Generative Adversarial Nets (GANs) [Liu et al., 2019a,b], training robust DNNs against adversarial examples is intrinsically different from GAN training.
Revised: While there are recent proposed algorithms for training Generative Adversarial Nets (GANs) [Liu et al., 2019a,b], training robust DNNs against adversarial examples is intrinsically different from GAN training.

Original: In particular, training robust DNNs requires inner maximization with respect to each training data rather than empirical maximization with respect to model parameters.
Revised: In particular, training robust DNNs requires inner maximization with respect to each training data rather than empirical maximization with respect to model parameters.

Original: Such an essential difference leads to different optimization goals, algorithms, convergence analyses and implementations.
Revised: Such an essential difference leads to different optimization goals, algorithms, convergence analyses and implementations.

Original:  PROBLEM FORMULATION
Revised:  PROBLEM FORMULATION

Original: In this section, we first review the standard setup of adversarial training (AT)
Revised: In this section, we ﬁrst review the standard setup of adversarial training (AT)

Original: [Madry et al., 2017], and then propose a general min-max setup for distributed AT (DAT).
Revised: [Madry et al., 2017], and then propose a general min-max setup for distributed AT (DAT).

Original: Adversarial training.
Revised: Adversarial training.

Original: AT [Madry et al., 2017] is a minmax optimization method for training robust ML/DL models against adversarial examples [Goodfellow et al., 2015].
Revised: AT [Madry et al., 2017] is a minmax optimization method for training robust ML/DL models against adversarial examples [Goodfellow et al., 2015].

Original: Formally, AT solves the problem minimize θ
Revised: Formally, AT solves the problem minimize ✓

Original: [Equation]
Revised: [Equation]

Original: where θ ∈ R d denotes the vector of model parameters, δ ∈ R n is the vector of input perturbations within an ℓ ∞ ball of the given radius ϵ , namely, ∥ δ ∥ ∞ ≤ ϵ , ( x , y ) ∈ D corresponds to the training example x with label y in the dataset D , and ℓ represents a pre-defined training loss, e.g., the cross-entropy (CE) loss.
Revised: where ✓ 2 R d denotes the vector of model parameters,  2 R n is the vector of input perturbations within an ` 1 ball of the given radius ✏ , namely, k  k 1  ✏ , ( x , y ) 2 D corresponds to the training example x with label y in the dataset D , and ` represents a pre-deﬁned training loss, e.g., the cross-entropy (CE) loss.

Original: The rationale behind problem (1) is that the model θ is robustly trained against the worst-case loss induced by the adversarially perturbed samples.
Revised: The rationale behind problem (1) is that the model ✓ is robustly trained against the worst-case loss induced by the adversarially perturbed samples.

Original: It is worth noting that the AT problem (1) is different from conventional stochastic min-max optimization problems, e.g., GANs training [Goodfellow et al., 2014].
Revised: It is worth noting that the AT problem (1) is different from conventional stochastic min-max optimization problems, e.g., GANs training [Goodfellow et al., 2014].

Original: Note that in (1), the stochastic sampling corresponding to the expectation over ( x , y ) ∈ D is conducted prior to the inner maximization operation.
Revised: Note that in (1), the stochastic sampling corresponding to the expectation over ( x , y ) 2 D is conducted prior to the inner maximization operation.

Original: Such a difference leads to the sample-specific adversarial perturbation δ ( x ) :
Revised: Such a difference leads to the sample-speciﬁc adversarial perturbation  ( x ) :

Original: = maximize ∥ δ ∥ ∞ ≤ ϵ ℓ ( θ , x + δ ; y ) .
Revised: = maximize k  k 1  ✏ ` ( ✓ , x +  ; y ) .

Original: Distributed AT (DAT).
Revised: Distributed AT (DAT).

Original: Let us consider a popular parameter-server model of distributed learning [Dean et al., 2012].
Revised: Let us consider a popular parameter-server model of distributed learning [Dean et al., 2012].

Original: Formally, there exist M workers each of which has access to a local dataset D ( i ) , and thus D =∪ M i
Revised: Formally, there exist M workers each of which has access to a local dataset D ( i ) , and thus D =

Original:  =1 D ( i ) .
Revised: [ Mi =1 D ( i ) .

Original: There also exists a server/master node (e.g., one of workers could perform as server), which collects local information (e.g., individual gradients) from the other workers to update the model parameters θ .
Revised: There also exists a server/master node (e.g., one of workers could perform as server), which collects local information (e.g., individual gradients) from the other workers to update the model parameters ✓ .

Original: Spurred by (1), DAT solves problems of the following generic form, minimize θ
Revised: Spurred by (1), DAT solves problems of the following generic form, minimize ✓

Original: [Equation]
Revised: [Equation]

Original: where f i denotes the local cost function at the i th worker, ϕ is a robustness regularizer against the input perturbation δ , and λ ≥ 0 is a regularization parameter that strikes a balance between the training loss and the worst-case robustness regularization.
Revised: where f i denotes the local cost function at the i th worker,  is a robustness regularizer against the input perturbation  , and   0 is a regularization parameter that strikes a balance between the training loss and the worst-case robustness regularization.

Original: In (2), if M = 1 , D (1) =
Revised: In (2), if M = 1 , D (1) =

Original: D , λ = 0 and ϕ = ℓ , then the DAT problem reduces to the AT problem (1).
Revised: D ,  = 0 and  = ` , then the DAT problem reduces to the AT problem (1).

Original: We cover two categories of (2).
Revised: We cover two categories of (2).

Original: ① DAT with labeled data: In (2), we consider ϕ ( θ , δ ; x , y ) =
Revised: ¨ DAT with labeled data: In (2), we consider  ( ✓ ,  ; x , y ) =

Original: ℓ ( θ , x + δ ; y ) with labeled training data ( x , y ) ∈ D ( i ) for i ∈
Revised: ` ( ✓ , x +  ; y ) with labeled training data ( x , y ) 2 D ( i ) for i 2 [ M ] .

Original: [ M ] . Here [ M ] denotes the integer set { 1 , 2 , . . .
Revised: Here [ M ] denotes the integer set { 1 , 2 , . . .

Original: , M } .
Revised: , M } .

Original: ② DAT with unlabeled data: In (2), different from DAT with labeled data, we augment D ( i ) with an unlabeled dataset, and define the robust regularizer ϕ as the pseudo-labeled worst-case
Revised: ≠ DAT with unlabeled data: In (2), different from DAT with labeled data, we augment D ( i ) with an unlabeled dataset, and deﬁne the robust regularizer  as the pseudo-labeled worst-case

Original: CE loss [Carmon et al., 2019] or the TRADES regularizer
Revised: CE loss [Carmon et al., 2019] or the TRADES regularizer

Original: [Stanforth et al., 2019, Zhang et al., 2019b].
Revised: [Stanforth et al., 2019, Zhang et al., 2019b].

Original:  METHODOLOGIES
Revised:  METHODOLOGIES

Original: At the first glance, distributed learning seems being naturally applied since problem (2) is decomposable over multiple workers.
Revised: At the ﬁrst glance, distributed learning seems being naturally applied since problem (2) is decomposable over multiple workers.

Original: Yet, the actual case is much more complex.
Revised: Yet, the actual case is much more complex.

Original: First , in contrast to standard AT, DAT allows for using a
Revised: First , in contrast to standard AT, DAT allows for using a

Original: M times larger batch size to update the model parameters θ in (2).
Revised: M times larger batch size to update the model parameters ✓ in (2).

Original: Thus, given the same number of epochs, DAT takes M fewer gradient updates than AT.
Revised: Thus, given the same number of epochs, DAT takes M fewer gradient updates than AT.

Original: Although there exist some large-batch model training techniques for solving min-only problems [You et al., 2017a,b, 2018, 2019,
Revised: Although there exist some large-batch model training techniques for solving min-only problems [You et al., 2017a,b, 2018, 2019,

Original: Goyal et al., 2017, Keskar et al., 2016], it remains unclear if they are effective to DAT due to its min-max optimization nature.
Revised: Goyal et al., 2017, Keskar et al., 2017], it remains unclear if they are effective to DAT due to its min-max optimization nature.

Original: Second , either AT or distributed learning has its own challenges.
Revised: Second , either AT or distributed learning has its own challenges.

Original: In AT, for ease of attack generation, i.e., conducting inner maximization of (2), fast gradient sign method (FGSM) was leveraged to improve its computation efficiency [Wong et al., 2020].
Revised: In AT, for ease of attack generation, i.e., conducting inner maximization of (2), fast gradient sign method (FGSM) was leveraged to improve its computation efﬁciency [Wong et al., 2020].

Original: In distributed learning, gradient compression [Alistarh et al., 2017, Yu et al., 2019] was used for reducing communication overhead.
Revised: In distributed learning, gradient compression [Alistarh et al., 2017, Yu et al., 2019] was used for reducing communication overhead.

Original: Thus, it also remains unclear whether these customizations are adaptable to DAT.
Revised: Thus, it also remains unclear whether these customizations are adaptable to DAT.

Original: In a nutshell, the distributed min-max optimizationbased robust training algorithm has not been well studied previously, particularly in the use of different types of attack generators (inner maximization oracles), gradient quantization, large-batch size, and adaptive learning rate.
Revised: In a nutshell, the distributed min-max optimizationbased robust training algorithm has not been well studied previously, particularly in the use of different types of attack generators (inner maximization oracles), gradient quantization, large-batch size, and adaptive learning rate.

Original: Although either of the standalone techniques was studied separately, justifying their coherent integration ‘actually works’ (both practically and theoretically) is quite demanding.
Revised: Although either of the standalone techniques was studied separately, justifying their coherent integration ‘actually works’ (both practically and theoretically) is quite demanding.

Original: Algorithmic framework of DAT.
Revised: Algorithmic framework of DAT.

Original: DAT follows the framework of distributed learning with parameter server.
Revised: DAT follows the framework of distributed learning with parameter server.

Original: In what follows, we elaborate on its key components through its meta-form shown by Algorithm 1 (see its detailed version in Algorithm A1).
Revised: In what follows, we elaborate on its key components through its meta-form shown by Algorithm 1 (see its detailed version in Algorithm A1).

Original: DAT contains three algorithmic blocks.
Revised: DAT contains three algorithmic blocks.

Original: In the first block, every distributed worker calls for a maximization oracle to obtain the adversarial perturbation for each sample within a data batch, then computes the gradient of the local cost function f i in (2) with respect to (w.r.t.) model parameters θ .
Revised: In the ﬁrst block, every distributed worker calls for a maximization oracle to obtain the adversarial perturbation for each sample within a data batch, then computes the gradient of the local cost function f i in (2) with respect to (w.r.t.) model parameters ✓ .

Original: And every worker is allowed to quantize/compress the local gradient prior to transmission to the server.
Revised: And every worker is allowed to quantize/compress the local gradient prior to transmission to the server.

Original: In the second block, the server aggregates the local gradients, and transmits the aggregated gradient (or the quantized gradient) to the other workers.
Revised: In the second block, the server aggregates the local gradients, and transmits the aggregated gradient (or the quantized gradient) to the other workers.

Original: In the third block, the model parameters are eventually updated by a minimization oracle at each worker based on the received gradient information from the server.
Revised: In the third block, the model parameters are eventually updated by a minimization oracle at each worker based on the received gradient information from the server.

Original: Algorithm
Revised: Algorithm

Original: 1: for Worker i = 1 , 2 , . . .
Revised: 1: for Worker i = 1 , 2 , . . .

Original: , M do ▷ Block2:{+. Block
+}
Revised: , M do {+. Block
+}

Original: Sample-wise attack generation (A1) 3:
Revised: Sample-wise attack generation (A1) 3:

Original: Local gradient computation (A2) 4:
Revised: Local gradient computation (A2) 4:

Original: Worker-server communication 5: end for 6: Gradient aggregation at server (A3) 
Revised: Worker-server communication 5: end for 6: Gradient aggregation at server (A3) .

Original: ▷ Block7: Server-worker communication 8: for Worker i = 1 , 2 , . ..
Revised: Block7: Server-worker communication 8: for Worker i = 1 , 2 , . .

Original: , M do ▷ Block9:
Revised: , M do . Block9:

Original: Model parameter update (A4) 10: end for
Revised: Model parameter update (A4) 10: end for

Original: Large-batch challenge in DAT and a layerwise adaptive learning rate (LALR) solution.
Revised: Large-batch challenge in DAT and a layerwise adaptive learning rate (LALR) solution.

Original: In DAT, the aggregated gradient (Step 6 in Algorithm 1) is built on the data batch that is M times larger than the standard AT.
Revised: In DAT, the aggregated gradient (Step 6 in Algorithm 1) is built on the data batch that is M times larger than the standard AT.

Original: This leads to a large-batch challenge in min-max optimization.
Revised: This leads to a large-batch challenge in min-max optimization.

Original: This challenge can also be verified from Fig.
Revised: This challenge can also be veriﬁed from Fig.

Original: To overcome the large-batch challenge, we adopt the technique of layerwise adaptive learning rate (LALR), backed up by the recent successful applications to the standard training of largescale image classification and language modeling networks with large data batch [You et al., 2019, 2017b].
Revised: To overcome the large-batch challenge, we adopt the technique of layerwise adaptive learning rate (LALR), backed up by the recent successful applications to the standard training of largescale image classiﬁcation and language modeling networks with large data batch [You et al., 2019, 2017b].

Original: To be more specific, the model training recipe using LALR becomes
Revised: To be more speciﬁc, the model training recipe using LALR becomes

Original: [Equation]
Revised: [Equation]

Original: where θ t,i denotes the i th-layer parameters at iteration t , with θ t 
Revised: where ✓ t,i denotes the i th-layer parameters at iteration t , with ✓ t =

Original: = [ θ ⊤ t, 1 , . .
Revised: [ ✓ > t, 1 , . .

Original: , θ ⊤ t,h ] ⊤ , h is the number of layers, u t is a descent direction computed based on the firstorder gradient w.r.t.
Revised: , ✓ > t,h ] > , h is the number of layers, u t is a descent direction computed based on the ﬁrstorder gradient w.r.t.

Original: model parameters θ t , τ ( ∥ [Equation] t,i ∥ 2 )=
Revised: model parameters ✓ t , ⌧ ( k ✓ t,i k 2 )

Original:  min { max {∥ θ t,i ∥ 2 , c l } , c u } is a layerwise scaling factor of the adaptive learning rate[Equation] , and c
Revised: = min { max { k ✓ t,i k 2 , c l } , c u } is a layerwise scaling factor of the adaptive learning rate

Original: [Equation]
Revised: [Equation]

Original: = 0 and c u =are set in our experiments (see Appendix 4.1 for some ablation studies on hyperparameter selection).
Revised: are set in our experiments (see Appendix 4.1 for some ablation studies on hyperparameter selection).

Original: In (3), the specific form of the descent direction u t is determined by the optimizer employed.
Revised: In (3), the speciﬁc form of the descent direction u t is determined by the optimizer employed.

Original: For example, if the adaptive momentum (Adam) method is used, then u t is given by the exponential moving average of past gradients scaled by square root of exponential moving averages of squared past gradients
Revised: For example, if the adaptive momentum (Adam) method is used, then u t is given by the exponential moving average of past gradients scaled by square root of exponential moving averages of squared past gradients

Original: [Reddi et al., 2018, Chen et al., 2018].
Revised: [Reddi et al., 2018, Chen et al., 2018].

Original: Such a variant of (3) that uses Adam as the base algorithm is also known as LAMB [You et al., 2019] in standard training.
Revised: Such a variant of (3) that uses Adam as the base algorithm is also known as LAMB [You et al., 2019] in standard training.

Original: However, it was elusive if the advantage of LALR is preserved in large-batch min-max optimization.
Revised: However, it was elusive if the advantage of LALR is preserved in large-batch min-max optimization.

Original: As will be evident later, the effectiveness of LALR in DAT can be justified from both theoretical and empirical perspectives.
Revised: As will be evident later, the effectiveness of LALR in DAT can be justiﬁed from both theoretical and empirical perspectives.

Original: The rationale is that the layer-wise adaptive learning rate smooths the optimization trajectory so that a larger learning rate can be used without causing sharp optima even in distributed min-max optimization.
Revised: The rationale is that the layer-wise adaptive learning rate smooths the optimization trajectory so that a larger learning rate can be used without causing sharp optima even in distributed min-max optimization.

Original: Other add-ons for DAT.
Revised: Other add-ons for DAT.

Original: In what follows, we illustrate two add-ons to improve computation and communication efficiency of DAT.
Revised: In what follows, we illustrate two add-ons to improve computation and communication efﬁciency of DAT.

Original: ➢ Inner maximization: Iterative vs. one-shot solution.
Revised: ‚ Inner maximization: Iterative vs. one-shot solution

Original: In
Revised: In

Original: DAT, each worker calls for an inner maximization oracle to generate adversarial perturbations (Step 2 of Algorithm 1).
Revised: DAT, each worker calls for an inner maximization oracle to generate adversarial perturbations (Step 2 of Algorithm 1).

Original: We specify two solvers of perturbation generation: iterative projected gradient descent (PGD) and one-shot (projected)
Revised: We specify two solvers of perturbation generation: iterative projected gradient descent (PGD) and one-shot (projected)

Original: FGSM [Goodfellow et al., 2015, Wong et al., 2020].
Revised: FGSM [Goodfellow et al., 2015, Wong et al., 2020].

Original: Our experiments will show that FGSM together with LALR works well in DAT.
Revised: Our experiments will show that FGSM together with LALR works well in DAT.

Original: We also remark that other techniques [Shafahi et al., 2019, Zhang et al., 2019a] can also be used to simplify inner maximization, however, we focus on FGSM since it is computationally lightest.
Revised: We also remark that other techniques [Shafahi et al., 2019, Zhang et al., 2019a] can also be used to simplify inner maximization, however, we focus on FGSM since it is computationally lightest.

Original: ➢ Gradient quantization.
Revised: ‚ Gradient quantization.

Original: In contrast to standard AT, DAT may call for worker-server communications (Steps 4 and 7 of Algorithm 1).
Revised: In contrast to standard AT, DAT may call for worker-server communications (Steps 4 and 7 of Algorithm 1).

Original: That is, if a single-precision floatingpoint data type is used, then DAT needs to transmit 32 d bits per worker-server communication at each iteration.
Revised: That is, if a single-precision ﬂoatingpoint data type is used, then DAT needs to transmit 32 d bits per worker-server communication at each iteration.

Original: Recall that d is the dimension of θ .
Revised: Recall that d is the dimension of ✓ .

Original: In order to reduce the communication cost, DAT has the option to quantize the transmitted gradients using a fixed number of bits fewer than 32 .
Revised: In order to reduce the communication cost, DAT has the option to quantize the transmitted gradients using a ﬁxed number of bits fewer than 32 .

Original: We specify the gradient quantization operation as the randomized quantizer [Alistarh et al., 2017, Yu et al., 2019].
Revised: We specify the gradient quantization operation as the randomized quantizer [Alistarh et al., 2017, Yu et al., 2019].

Original: In Sec.
Revised: In Sec.

Original: 6 we will show that DAT, combined with gradient quantization, still leads to a competitive performance.
Revised: 6 we will show that DAT, combined with gradient quantization, still leads to a competitive performance.

Original: For example, the robust accuracy of ResNet-50 trained by a 8bit DAT (performing quantization at Step 4 of Algorithm 1) for ImageNet is just 0 .
Revised: For example, the robust accuracy of ResNet-50 trained by a 8bit DAT (performing quantization at Step 4 of Algorithm 1) for ImageNet is just 0 .

Original: 55% lower than the robust accuracy achieved by the 32 -bit DAT.
Revised: 55% lower than the robust accuracy achieved by the 32 -bit DAT.

Original: It is also worth mentioning that the All-reduce communication protocol can be regarded as a special case of the parameter-server setting in Algorithmwhen every worker performs as a server.
Revised: It is also worth mentioning that the All-reduce communication protocol can be regarded as a special case of the parameter-server setting in Algorithmwhen every worker performs as a server.

Original: In this case, the communication network becomes fully connected and only the worker-server communication (Step 4 of Algorithm 1) is needed.
Revised: In this case, the communication network becomes fully connected and only the worker-server communication (Step 4 of Algorithm 1) is needed.

Original: Please refer to Appendix 1 for more details on gradient quantization.
Revised: Please refer to Appendix 1 for more details on gradient quantization.

Original:  CONVERGENCE ANALYSIS OF DAT
Revised:  CONVERGENCE ANALYSIS OF DAT

Original: Although standard AT has been proved with convergence guarantees [Wang et al., 2019b, Gao et al., 2019], none of existing work addressed the convergence of DAT and took into account LALR and gradient quantization, even in the standard AT setup.
Revised: Although standard AT has been proved with convergence guarantees [Wang et al., 2019b, Gao et al., 2019], none of existing work addressed the convergence of DAT and took into account LALR and gradient quantization, even in the standard AT setup.

Original: Different from AT, DAT needs to quantify the descent errors from multiple sources (such as gradient estimation, quantization, adaptive learning rate, and inner maximization oracle).
Revised: Different from AT, DAT needs to quantify the descent errors from multiple sources (such as gradient estimation, quantization, adaptive learning rate, and inner maximization oracle).

Original: Before showing the challenges of proving the convergence rate guarantees, we first give the following assumptions.
Revised: Before showing the challenges of proving the convergence rate guarantees, we ﬁrst give the following assumptions.

Original: Assumptions.
Revised: Assumptions.

Original: Defining Ψ ( θ ) :
Revised: Deﬁning ( ✓ ) :

Original: = 1 M(cid:80) Mi =
Revised: = 1 M

Original: 1 f i ( θ ; D ( i ) ) in (2), we measure the convergence of DAT by the first-order stationarity ofΨ .
Revised: P Mi =1 f i ( ✓ ; D ( i ) ) in (2), we measure the convergence of DAT by the ﬁrst-order stationarity of .

Original: Prior to convergence analysis, we impose the following assumptions: ( A 1 ) Ψ( θ ) is with layer-wise
Revised: Prior to convergence analysis, we impose the following assumptions: ( A 1 ) ( ✓ ) is with layer-wise

Original: Lipschitz continuous gradients; ( A 2 ) ϕ ) in (2) is strongly concave with respect to δ and with Lipschitz continuous gradients within the perturbation constraint; (
Revised: Lipschitz continuous gradients; ( A 2 )  ) in (2) is strongly concave with respect to  and with Lipschitz continuous gradients within the perturbation constraint; (

Original: A 3 ) Stochastic gradient is unbiased and has bounded variance for each worker denoted by σ 2 .
Revised: A 3 ) Stochastic gradient is unbiased and has bounded variance for each worker denoted by  2 .

Original: Note that the validity of ( A 2 ) could be justified from [Sinha et al., 2018, Wang et al., 2019b] by imposing a strongly convex regularization into the neighborhood of δ .
Revised: Note that the validity of ( A 2 ) could be justiﬁed from [Sinha et al., 2018, Wang et al., 2019b] by imposing a strongly convex regularization into the neighborhood of  .

Original: A 2 is needed for tractability of analysis.
Revised: A 2 is needed for tractability of analysis.

Original: We refer readers to Appendix 2.1 for more justifications on our assumptions ( A 1 )-
Revised: We refer readers to Appendix 2.1 for more justiﬁcations on our assumptions ( A 1 )-

Original: ( A 3 ).
Revised: ( A 3 ).

Original: Technical challenges.
Revised: Technical challenges.

Original: In theory, the incorporation of
Revised: In theory, the incorporation of

Original: LALR makes the analysis of min-max optimization highly non-trivial.
Revised: LALR makes the analysis of min-max optimization highly non-trivial.

Original: The fundamental challenge lies in the nonlinear coupling between the biased adaptive gradient estimate resulted from LALR and the additional error generated from alternating update in DAT.
Revised: The fundamental challenge lies in the nonlinear coupling between the biased adaptive gradient estimate resulted from LALR and the additional error generated from alternating update in DAT.

Original: From (3), we can see that the updated θ is based on the normalized gradient, while if we perform convergence by applying the gradient Lipschitz continuity, the descent of the objective is measured by ∇ Ψ( θ t ) .
Revised: From (3), we can see that the updated ✓ is based on the normalized gradient, while if we perform convergence by applying the gradient Lipschitz continuity, the descent of the objective is measured by r ( ✓ t ) .

Original: This mismatch in the magnitude results in the bias term.
Revised: This mismatch in the magnitude results in the bias term.

Original: The situation here is even worse, since the maximization problem cannot be solved exactly, the size of the bias depends on how close between the output of the oracle and the optimal solution w.r.t.
Revised: The situation here is even worse, since the maximization problem cannot be solved exactly, the size of the bias depends on how close between the output of the oracle and the optimal solution w.r.t.

Original: δ given θ .
Revised:  given ✓ .

Original: We have proposed a new descent lemma (Lemma 2 in Appendix) to measure the decrease of the objective value in the context of alternative optimization, and showed that the bias error resulted from the layer-wise normalization can be compensated by large-batch training (Theorem 1).
Revised: We have proposed a new descent lemma (Lemma 2 in Appendix) to measure the decrease of the objective value in the context of alternative optimization, and showed that the bias error resulted from the layer-wise normalization can be compensated by large-batch training (Theorem 1).

Original: Prior to our work, we are not aware of any established convergence analysis for large-batch min-max optimization.
Revised: Prior to our work, we are not aware of any established convergence analysis for large-batch min-max optimization.

Original: Convergence rate.
Revised: Convergence rate.

Original: In Theorem 1, we present the sublinear rate of DAT.
Revised: In Theorem 1, we present the sublinear rate of DAT.

Original: Theorem 1.
Revised: Theorem 1.

Original: Suppose that assumptions A 1 - A 3 hold, the inner maximizer of DAT provides a ε -approximate solution (i.e., the ℓ 2 -norm of inner gradient is upper bounded by ε ), and the learning rate is set by η t ∼ O (1 / √ T ) , then { θ t } Tt =1 generated by DAT yields the convergence rate
Revised: Suppose that assumptions A 1 - A 3 hold, the inner maximizer of DAT provides a " -approximate solution (i.e., the ` 2 -norm of inner gradient is upper bounded by " ), and the learning rate is set by ⌘ t ⇠ O (1 / p T ) , then { ✓ t } Tt =1 generated by DAT yields the convergence rate

Original: [Equation]
Revised: [Equation]

Original: where b denotes the number of quantization bits, and
Revised: where b denotes the number of quantization bits, and

Original: B = min {|B ( i ) t | , ∀ t, i } stands for the smallest batch size per worker.
Revised: B = min {|B ( i ) t | , 8 t, i } stands for the smallest batch size per worker.

Original: Proof : Please see Appendix 3.
Revised: Proof : Please see Appendix 3.

Original: □
Revised: ⇤

Original: The error rate given by (4) involves four terms.
Revised: The error rate given by (4) involves four terms.

Original: The term
Revised: The term

Original: O (1 / √ MB ) characterizes the benefit of using the large per-worker batch size B and M computing nodes in DAT.
Revised: O (1 / p MB ) characterizes the beneﬁt of using the large per-worker batch size B and M computing nodes in DAT.

Original: It is introduced since the variance of adaptive gradients (i.e., σ 2 ) is reduced by a factor 1 /MB , where 1 /M corresponds to the linear speedup by M machines.
Revised: It is introduced since the variance of adaptive gradients (i.e.,  2 ) is reduced by a factor 1 /MB , where 1 /M corresponds to the linear speedup by M machines.

Original: In (4), the term min { d 4 b , √ d 2 b } arises due to the variance of compressed gradients, and the other two terms imply the dependence on the number of iterations T as well as the ε -accuracy of the inner maximization oracle.
Revised: In (4), the term min { d 4 b , p d 2 b } arises due to the variance of compressed gradients, and the other two terms imply the dependence on the number of iterations T as well as the " -accuracy of the inner maximization oracle.

Original: We highlight that our convergence analysis (Theorem 1) is not barely a combination of
Revised: We highlight that our convergence analysis (Theorem 1) is not barely a combination of

Original: LALR-enabled standard training analysis [You et al., 2019, 2017b] and adversarial training convergence analysis [Wang et al., 2019b, Gao et al., 2019].
Revised: LALR-enabled standard training analysis [You et al., 2019, 2017b] and adversarial training convergence analysis [Wang et al., 2019b, Gao et al., 2019].

Original: Different from the previous work, we address the fundamental challenges in (a) quantifying the descent property of the objective value at the presence of multi-source errors during alternating min-max optimization, and (b) deriving the theoretical relationship between large data batch (across distributed machines) and the eventual convergence error of DAT.
Revised: Different from the previous work, we address the fundamental challenges in (a) quantifying the descent property of the objective value at the presence of multi-source errors during alternating min-max optimization, and (b) deriving the theoretical relationship between large data batch (across distributed machines) and the eventual convergence error of DAT.

Original:  EXPERIMENTS
Revised:  EXPERIMENTS

Original: We empirically evaluate DAT and show its success in training robust DNNs across multiple applications, which include ① adversarially robust ImageNet training, ② provably robust training by randomized smoothing, ③ semisupervised robust training with unlabeled data, ④ robust transfer learning, ⑤ DAT using different communication protocols.
Revised: We empirically evaluate DAT and show its success in training robust DNNs across multiple applications, which include ¨ adversarially robust ImageNet training, ≠ provably robust training by randomized smoothing, Æ semisupervised robust training with unlabeled data, Ø robust transfer learning, ∞ DAT using different communication protocols.

Original: 6.1 EXPERIMENT SETUP
Revised: 6.1 EXPERIMENT SETUP

Original: DNN models and datasets.
Revised: DNN models and datasets.

Original: We use Pre-act ResNet-
Revised: We use Pre-act ResNet-

Original: [He et al., 2016b] and ResNet-

Revised: [He et al., 2016b] and ResNet-

Original: [He et al., 2016a] for image classification, where the former is shortened as ResNet-18.
Revised: [He et al., 2016a] for image classiﬁcation, where the former is shortened as ResNet-18.

Original: And we use ImageNet [Deng et al., 2009] for supervised
Revised: And we use ImageNet [Deng et al., 2009] for supervised

Original: DAT and augmented CIFAR-10 [Carmon et al., 2019] for semi-supervised DAT.
Revised: DAT and augmented CIFAR-10 [Carmon et al., 2019] for semi-supervised DAT.

Original: In the latter setup, CIFAR-10 is augmented with unlabeled data drawn from 80 Million Tiny
Revised: In the latter setup, CIFAR-10 is augmented with unlabeled data drawn from 80 Million Tiny

Original: Images.
Revised: Images.

Original: When studying pre-trained model’s transferability, CIFAR-100 is used as a target dataset for down-stream classification.
Revised: When studying pre-trained model’s transferability, CIFAR-100 is used as a target dataset for down-stream classiﬁcation.

Original: Computing resources.
Revised: Computing resources.

Original: We train a DNN using p computing nodes, each of which contains q GPUs (Nvidia V100 or
Revised: We train a DNN using p computing nodes, each of which contains q GPUs (Nvidia V100 or

Original: P100).
Revised: P100).

Original: Nodes are connected with 1Gbps ethernet.
Revised: Nodes are connected with 1Gbps ethernet.

Original: A configuration of computing resources is noted by p × q .
Revised: A conﬁguration of computing resources is noted by p ⇥ q .

Original: If p > 1 , then the training is conducted in a distributed manner.
Revised: If p > 1 , then the training is conducted in a distributed manner.

Original: And we split training data into p subsets, each of which is stored at a local node.
Revised: And we split training data into p subsets, each of which is stored at a local node.

Original: We note that the batch size 6 × 512{+⇥ 
+} =is used for ImageNet over 36 GPUs.
Revised: We note that the batch size 6 {+⇥ 
+} =is used for ImageNet over 36 GPUs.

Original: Unless specified otherwise, DAT is conducted using Ring-AllReduce, which requires one-sided quantization in Step 4 of Algorithm 1.
Revised: Unless speciﬁed otherwise, DAT is conducted using Ring-AllReduce, which requires one-sided quantization in Step 4 of Algorithm 1.

Original: Baseline methods.
Revised: Baseline methods.

Original: We consider 2 variants of DAT: 1) DAT-PGD , namely, DAT using (iterative) PGD as the inner maximization oracle; and 2) DAT-FGSM , namely, DAT using one-step (projected) FGSM
Revised: We consider 2 variants of DAT: 1) DAT-PGD , namely, DAT using (iterative) PGD as the inner maximization oracle; and 2) DAT-FGSM , namely, DAT using one-step (projected) FGSM

Original: [Wong et al., 2020] as the inner maximization oracle.
Revised: [Wong et al., 2020] as the inner maximization oracle.

Original: Additionally, we consider 4 training baselines : 1) AT [Madry et al., 2017]; 2)
Revised: Additionally, we consider 4 training baselines : 1) AT [Madry et al., 2017]; 2)

Original: Fast AT [Wong et al., 2020]; 3) DAT w/o LALR , namely, a distributed implementation of AT or Fast AT
Revised: Fast AT [Wong et al., 2020]; 3) DAT w/o LALR , namely, a distributed implementation of AT or Fast AT

Original: but without considering LALR; and 4) DAT-LSGD
Revised: but without considering LALR; and 4) DAT-LSGD

Original: [Xie et al., 2019], namely, a distributed implementation of large-batch SGD (LSGD) for AT.
Revised: [Xie et al., 2019], namely, a distributed implementation of large-batch SGD (LSGD) for AT.

Original: We remark that conventional AT and Fast AT are centralized training methods.
Revised: We remark that conventional AT and Fast AT are centralized training methods.

Original: [Table]
Revised: [Table]

Original: Training setting.
Revised: Training setting.

Original: Unless specified otherwise, we choose the training perturbation size ϵ = 8 / 255 and 2 / 255 for
Revised: Unless speciﬁed otherwise, we choose the training perturbation size ✏ = 8 / 255 and 2 / 255 for

Original: CIFAR and ImageNet respectively, where recall that ϵ was defined in (1).
Revised: CIFAR and ImageNet respectively, where recall that ✏ was deﬁned in (1).

Original: We also choose 10 steps and 4 steps for PGD attack generation in DAT (and its variants) under CIFAR and ImageNet, respectively.
Revised: We also choose 10 steps and 4 steps for PGD attack generation in DAT (and its variants) under CIFAR and ImageNet, respectively.

Original: The number of training epochs is given by 100 for CIFAR-10 and 30 for ImageNet.
Revised: The number of training epochs is given by 100 for CIFAR-10 and 30 for ImageNet.

Original: Such training settings are consistent with previous state-of-the-art [Zhang et al., 2019a, Wong et al., 2020].
Revised: Such training settings are consistent with previous state-of-the-art [Zhang et al., 2019a, Wong et al., 2020].

Original: To implement DATFGSM, we find that the use of cyclic learning rate suggested by Fast AT [Wong et al., 2020] becomes over-sensitive to the increase of batch size; see Appendix 4.2.
Revised: To implement DATFGSM, we ﬁnd that the use of cyclic learning rate suggested by Fast AT [Wong et al., 2020] becomes over-sensitive to the increase of batch size; see Appendix 4.2.

Original: Thus, we adopt the standard piecewise decay step size and an early-stop strategy [Rice et al., 2020] in DAT.
Revised: Thus, we adopt the standard piecewise decay step size and an early-stop strategy [Rice et al., 2020] in DAT.

Original: Evaluation setting.
Revised: Evaluation setting.

Original: Unless specified otherwise, we report robust test accuracy ( RA ) of a learned model against PGD attacks [Madry et al., 2017].
Revised: Unless speciﬁed otherwise, we report robust test accuracy ( RA ) of a learned model against PGD attacks [Madry et al., 2017].

Original: Unless specified otherwise, we choose the perturbation size same as the training ϵ in evaluation, and the number of PGD steps is selected asand 10 for CIFAR and ImageNet, respectively.
Revised: Unless speciﬁed otherwise, we choose the perturbation size same as the training ✏ in evaluation, and the number of PGD steps is selected asand 10 for CIFAR and ImageNet, respectively.

Original: We will also measure RA against AutoAttacks and the resulting robust accuracy is named AA .
Revised: We will also measure RA against AutoAttacks and the resulting robust accuracy is named AA .

Original: Further, we measure the standard test accuracy ( TA ) of a model against normal examples.
Revised: Further, we measure the standard test accuracy ( TA ) of a model against normal examples.

Original: All experiments are run 3 times with different random seeds, and the mean metrics are reported.
Revised: All experiments are run 3 times with different random seeds, and the mean metrics are reported.

Original: We consider three different communication protocols, Ring-AllReduce (with one-sided quantization), parameter-server (with double quantization), and high performance computing (HPC) setting (without quantization).
Revised: We consider three different communication protocols, Ring-AllReduce (with one-sided quantization), parameter-server (with double quantization), and high performance computing (HPC) setting (without quantization).

Original: To measure the communication time, we use
Revised: To measure the communication time, we use

Original: TORCH .
Revised: TORCH .

Original: DISTRIBUTED package with gloo and nccl as communication backend 1 .
Revised: DISTRIBUTED package with gloo and nccl as communication backend 1 .

Original: We then measure the time of required worker-server communications per epoch.
Revised: We then measure the time of required worker-server communications per epoch.

Original: 6.2 EXPERIMENT RESULTS
Revised: 6.2 EXPERIMENT RESULTS

Original: Adversarial training on ImageNet.
Revised: Adversarial training on ImageNet.

Original: In Table 1, we show an overall performance comparison on ImageNet between our proposed DAT variants and baselines in TA, RA, communication and computation efficiency.
Revised: In Table 1, we show an overall performance comparison on ImageNet between our proposed DAT variants and baselines in TA, RA, communication and computation efﬁciency.

Original: Note that AT and
Revised: Note that AT and

Original: Fast AT are centralized training baselines using the same number of epochs as distributed training.
Revised: Fast AT are centralized training baselines using the same number of epochs as distributed training.

Original: First , we observe that the direct extension from AT (or Fast AT) to its distributed counterpart (namely, DAT-PGD w/o LALR or DAT-FGSM w/o LALR) leads to a large degradation of both RA and TA.
Revised: First , we observe that the direct extension from AT (or Fast AT) to its distributed counterpart (namely, DAT-PGD w/o LALR or DAT-FGSM w/o LALR) leads to a large degradation of both RA and TA.

Original: Second , DAT-PGD (or DAT-FGSM) is able to achieve competitive performance to AT (or Fast
Revised: Second , DAT-PGD (or DAT-FGSM) is able to achieve competitive performance to AT (or Fast

Original: AT) and enables a graceful training speedup.
Revised: AT) and enables a graceful training speedup.

Original: In practice,
Revised: In practice,

Original: DAT is not able to achieve linear speed-up mainly because of the communication cost.
Revised: DAT is not able to achieve linear speed-up mainly because of the communication cost.

Original: For example, when comparing the computation time of DAT-PGD (batch size 6 × 512 ) with that of AT (batch size 512 ), the computation speedup (by excluding the communication cost) is given by (6022) /
Revised: For example, when comparing the computation time of DAT-PGD (batch size 6 ⇥ 512 ) with that of AT (batch size 512 ), the computation speedup (by excluding the communication cost) is given by (6022) /

Original: (1960 − 898) = 5 .
Revised: (1960  898) = 5 .

Original: 67 , consistent with the ideal computation gain using 6 × larger batch size in DAT-PGD.
Revised: 67 , consistent with the ideal computation gain using 6 ⇥ larger batch size in DAT-PGD.

Original: Third , when comparing DAT-FGSM with DAT-PGD, we observe that the former leads to a larger loss in standard accuracy (around 5%).
Revised: Third , when comparing DAT-FGSM with DAT-PGD, we observe that the former leads to a larger loss in standard accuracy (around 5%).

Original: Moreover, similar to Fast AT, we noted a larger RA variance of DAT-FGSM (around 1.5%) than DAT-PGD (around 0.5%).
Revised: Moreover, similar to Fast AT, we noted a larger RA variance of DAT-FGSM (around 1.5%) than DAT-PGD (around 0.5%).

Original: Thus, the FGSM-based training is less stable than the AT-based one, consistent with [Li et al., 2020].
Revised: Thus, the FGSM-based training is less stable than the AT-based one, consistent with [Li et al., 2020].

Original: [Figure]
Revised: [Figure]

Original: [Figure] In Figure [Figure] we further compare our proposed DAT with the
Revised: In Figure 2, we further compare our proposed DAT with the

Original: DAT-LSGD baseline
Revised: DAT-LSGD baseline

Original: [Xie et al., 2019] in terms of TA/RA versus the number of computing nodes.
Revised: [Xie et al., 2019] in terms of TA/RA versus the number of computing nodes.

Original: Clearly, our approach scales more gracefully than the baseline, without losing much performance as the batch sizes increases along with the number of computing nodes.
Revised: Clearly, our approach scales more gracefully than the baseline, without losing much performance as the batch sizes increases along with the number of computing nodes.

Original: It is worth noting that our DAT setup is more challenging than [Xie et al., 2019], which used 128 GPUs but the per-GPU utilization is the 32 batch size.
Revised: It is worth noting that our DAT setup is more challenging than [Xie et al., 2019], which used 128 GPUs but the per-GPU utilization is the 32 batch size.

Original: By contrast, although we only use
Revised: By contrast, although we only use

Original: GPUs, the per-GPU batch size is 85.
Revised: GPUs, the per-GPU batch size is 85.

Original: The use of a larger batch size per GPU makes distributed robust training useful when having access to a limited computing budget.
Revised: The use of a larger batch size per GPU makes distributed robust training useful when having access to a limited computing budget.

Original: Besides, Xie et al.
Revised: Besides, Xie et al.

Original: [2019] used the PGD attack generation with a quite large number of attack steps (30) at the training time.
Revised: [2019] used the PGD attack generation with a quite large number of attack steps (30) at the training time.

Original: This makes the computation time dominated over the node-wise communication time.
Revised: This makes the computation time dominated over the node-wise communication time.

Original: However, we used a less number of PGD attack steps.
Revised: However, we used a less number of PGD attack steps.

Original: In this scenario, the communication time cannot be neglected and prevents the practical distributed implementation from achieving the linear speedup.
Revised: In this scenario, the communication time cannot be neglected and prevents the practical distributed implementation from achieving the linear speedup.

Original: For example, when comparing the computation time of DAT-PGD with that of AT in Table 1, the computation speed-up (by excluding communication cost) is given by 6022 / (1960 − 898) = 5 .
Revised: For example, when comparing the computation time of DAT-PGD with that of AT in Table 1, the computation speed-up (by excluding communication cost) is given by 6022 / (1960  898) = 5 .

Original: 67 , close to the linear rate (6 × ).
Revised: 67 , close to the linear rate (6 ⇥ ).

Original: In Figure 3, we evaluate the performance of DAT against
Revised: In Figure 3, we evaluate the performance of DAT against

Original: PGD attacks of different steps and perturbation sizes (i.e., values of ϵ ).
Revised: PGD attacks of different steps and perturbation sizes (i.e., values of ✏ ).

Original: We observe that DAT matches robust accuracies of standard AT even against PGD attacks at different values of ϵ and steps.
Revised: We observe that DAT matches robust accuracies of standard AT even against PGD attacks at different values of ✏ and steps.

Original: Adversarially trained smooth classifier.
Revised: Adversarially trained smooth classiﬁer.

Original: DAT also provides us an effective way to speed up the smooth adversarial training (Smooth-AT)
Revised: DAT also provides us an effective way to speed up the smooth adversarial training (Smooth-AT)

Original: [Salman et al., 2020] for certified robustness.
Revised: [Salman et al., 2020] for certiﬁed robustness.

Original: Different from AT, Smooth-AT augments a single training sample with multiple Gaussian noisy copies so as to train a Gaussian smoothing-aware classifier.
Revised: Different from AT, Smooth-AT augments a single training sample with multiple Gaussian noisy copies so as to train a Gaussian smoothing-aware classiﬁer.

Original: Thus, SmoothAT requires N × data batch size and storage capacity in contrast to AT, where N is the number of noisy copies per sample.
Revised: Thus, SmoothAT requires N ⇥ data batch size and storage capacity in contrast to AT, where N is the number of noisy copies per sample.

Original: In the centralized training regime, N can only be set by a small value, e.g., N = 1 or 2 .
Revised: In the centralized training regime, N can only be set by a small value, e.g., N = 1 or 2 .

Original: However, DAT is able to scale up Smooth-AT with a large value of N , e.g.,
Revised: However, DAT is able to scale up Smooth-AT with a large value of N , e.g.,

Original: N = 20 in Table 2.
Revised: N = 20 in Table 2.

Original: Here smooth classifiers are achieved at two Gaussian noise variance levels, σ = 0 .

Original: 12 and σ = 0 .

Original: 25 , following [Salman et al., 2020].

Original: And Smooth-AT is implemented using the baseline approach with N = 2 and the DAT approach with

Original: N = 20 , respectively.

Original: [Figure]
Revised: [Figure]

Original: Smooth-AT can produce a provably robust classifier [Cohen et al., 2019].
Revised: Smooth-AT can produce a provably robust classiﬁer [Cohen et al., 2019].

Original: To be more specific, let f ( x ) denote a classifier (with input x ) trained by Smooth-AT.
Revised: To be more speciﬁc, let f ( x ) denote a classiﬁer (with input x ) trained by Smooth-AT.

Original: Then its Gaussian smoothing version, given by f smooth ( x ) :=
Revised: Then its Gaussian smoothing version, given by f smooth ( x ) :=

Original: arg max c P δ ∈N ( 0 ,σ 2 I )
Revised: arg max c P  2 N ( 0 ,  2 I )

Original: [ f ( x + δ ) =
Revised: [ f ( x +  ) =

Original: c ] , can achieve certified robustness, where c is a class label, δ ∈ N ( 0 , σ 2 I ) denotes the standard Gaussian noise with variance σ 2 , and
Revised: c ] , can achieve certiﬁed robustness, where c is a class label,  2 N ( 0 ,  2 I ) denotes the standard Gaussian noise with variance  2 , and

Original: P signifies the majority vote-based prediction probability over multiple noisy samples.
Revised: P signiﬁes the majority vote-based prediction probability over multiple noisy samples.

Original: The resulting smooth classifier f smooth can then be evaluated at certified accuracy [Cohen et al., 2019], a provable robust guarantee at a given ℓperturbation radius r .
Revised: The resulting smooth classiﬁer f smooth can then be evaluated at certiﬁed accuracy [Cohen et al., 2019], a provable robust guarantee at a given `perturbation radius r .

Original: In Table 2, we present the certified accuracy (CA) of a σspecified smooth classifier, obtained by either the conventional Smooth-AT approach (baseline using N = 2 ) or the
Revised: In Table 2, we present the certiﬁed accuracy (CA) of a  - speciﬁed smooth classiﬁer, obtained by either the conventional Smooth-AT approach (baseline using N = 2 ) or the

Original: DAT-enabled Smooth-AT method (DAT using N = 20 ).
Revised: DAT-enabled Smooth-AT method (DAT using N = 20 ).

Original: And we evaluated CA at different ℓ 2 -radii.
Revised: And we evaluated CA at different ` 2 -radii.

Original: As we can see,
Revised: As we can see,

Original: DAT yields improved certified robustness over the conventional Smooth-AT with N = 2 .
Revised: DAT yields improved certiﬁed robustness over the conventional Smooth-AT with N = 2 .

Original: This demonstrates the advantage of DAT in training provably robust classifiers: The use of a large number of Gaussian noisy samples becomes feasible through distributed training.
Revised: This demonstrates the advantage of DAT in training provably robust classiﬁers: The use of a large number of Gaussian noisy samples becomes feasible through distributed training.

Original: We also observe that
Revised: We also observe that

Original: CA drops if the perturbation ℓ 2 -radius r increases.
Revised: CA drops if the perturbation ` 2 -radius r increases.

Original: This is not surprising since CA is derived by sanity checking if the certified ℓ 2 perturbation radius of a smooth classifier can cover a given r .
Revised: This is not surprising since CA is derived by sanity checking if the certiﬁed ` 2 perturbation radius of a smooth classiﬁer can cover a given r .

Original: Besides, the smoother classifier constructed using Gaussian noises of large variance σ tend to be more robust against a larger ℓ 2 perturbation radius, but may hamper the accuracy against perturbations of small ℓ 2 radius.
Revised: Besides, the smoother classiﬁer constructed using Gaussian noises of large variance  tend to be more robust against a larger ` 2 perturbation radius, but may hamper the accuracy against perturbations of small ` 2 radius.

Original: This is consistent with [Cohen et al., 2019] and reveals the tradeoff between accuracy and certified robustness for a σ -specific smooth classifier.
Revised: This is consistent with [Cohen et al., 2019] and reveals the tradeoff between accuracy and certiﬁed robustness for a  -speciﬁc smooth classiﬁer.

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Revised: under CIFAR-10 (a) and CIFAR-100 (b).

Revised: For compassion adversarial training on CIFAR datasets from scratch (no pretrain) is also presented.

Revised: Here DAT-PGD is used for both pre-training and ﬁne-tuning at 6 computing nodes.

Original: DAT under unlabeled data In Table 3, we report TA and
Revised: DAT under unlabeled data In Table 3, we report TA and

Original: RA of DAT in the semi-supervised setting [Carmon et al., 2019] with the use of 500K unlabeled images mined from
Revised: RA of DAT in the semi-supervised setting [Carmon et al., 2019] with the use of 500K unlabeled images mined from

Original: Tiny Images [Carmon et al., 2019].
Revised: Tiny Images [Carmon et al., 2019].

Original: As we can see, both DATPGD and DAT-FGSM scale well even if a 12 × batch size is used across 12 machines, each of which has a single GPU.
Revised: As we can see, both DATPGD and DAT-FGSM scale well even if a 12 ⇥ batch size is used across 12 machines, each of which has a single GPU.

Original: We also compare DAT-PGD with [Carmon et al., 2019] following the latter’s architecture, Wide ResNet 28-10.
Revised: We also compare DAT-PGD with [Carmon et al., 2019] following the latter’s architecture, Wide ResNet 28-10.

Original: We note that DAT-PGD yields 89 .
Revised: We note that DAT-PGD yields 89 .

Original: 37% TA and 58 .
Revised: 37% TA and 58 .

Original: 35% AA.
Revised: 35% AA.

Original: This is close to the reported 89 .
Revised: This is close to the reported 89 .

Original: 69% TA and 59 .
Revised: 69% TA and 59 .

Original: 53% AA in RobustBench [Croce et al., 2020] built upon small-batch adversarial training.
Revised: 53% AA in RobustBench [Croce et al., 2020] built upon small-batch adversarial training.

Original: Although the use of large data batch may cause a performance loss due to the reduced number of training iterations, the use of data augmentation serves as a remedy for such loss.
Revised: Although the use of large data batch may cause a performance loss due to the reduced number of training iterations, the use of data augmentation serves as a remedy for such loss.

Original: DAT from pre-training to fine-tuning.
Revised: DAT from pre-training to ﬁne-tuning.

Original: In Figure 4, we investigate if a DAT pre-trained model (ResNet-50) over a source dataset (ImageNet) can offer a fast fine-tuning to a down-stream target dataset (CIFAR-10/100).
Revised: In Figure 4, we investigate if a DAT pre-trained model (ResNet-50) over a source dataset (ImageNet) can offer a fast ﬁne-tuning to a down-stream target dataset (CIFAR-10/100).

Original: Here we up-sample a CIFAR image to the same dimension of an
Revised: Here we up-sample a CIFAR image to the same dimension of an

Original: ImageNet image before feeding it into the pre-trained model [Shafahi et al., 2020].
Revised: ImageNet image before feeding it into the pre-trained model [Shafahi et al., 2020].

Original: Compared with the direct application of DAT to the target dataset (without pre-training), the pretraining enables a fast adaption to the down-stream CIFAR task in both TA and RA within just 3 epochs.
Revised: Compared with the direct application of DAT to the target dataset (without pre-training), the pretraining enables a fast adaption to the down-stream CIFAR task in both TA and RA within just 3 epochs.

Original: Thus, the scalability of DAT to large datasets and multiple nodes offers a great potential to rapidly initialize an adversarially robust base model in the ‘pre-training + fine-tuning’ paradigm.
Revised: Thus, the scalability of DAT to large datasets and multiple nodes offers a great potential to rapidly initialize an adversarially robust base model in the ‘pre-training + ﬁne-tuning’ paradigm.

Original: Quantization effect in various communication protocols
Revised: Quantization effect in various communication protocols

Original: In Table 4, we present how DAT is affected by gradient quantization.
Revised: In Table 4, we present how DAT is affected by gradient quantization.

Original: As we can see, when the number of bits is reduced, the communication cost and the amount of transmitted data are saved, respectively.
Revised: As we can see, when the number of bits is reduced, the communication cost and the amount of transmitted data are saved, respectively.

Original: However, the use of an aggressive gradient quantization introduces a performance loss.
Revised: However, the use of an aggressive gradient quantization introduces a performance loss.

Original: For example, compared with the case of using 32 bits, the most aggressive quantization scheme ( 8 -bit 2 -sided quantization in Steps 4 and 7 of Algorithm 1) yields an RA drop around 4% and 7% for DAT-PGD and DAT-FGSM, respectively.
Revised: For example, compared with the case of using 32 bits, the most aggressive quantization scheme ( 8 -bit 2 -sided quantization in Steps 4 and 7 of Algorithm 1) yields an RA drop around 4% and 7% for DAT-PGD and DAT-FGSM, respectively.

Original: In particular, DAT-FGSM is more sensitive to the effect of gradient quantization than DAT-PGD.
Revised: In particular, DAT-FGSM is more sensitive to the effect of gradient quantization than DAT-PGD.

Original: It is worth noting that our main communication configuration used in previous experiments is Ring-AllReduce that calls for 1-sided (rather than 2-sided) quantization.
Revised: It is worth noting that our main communication conﬁguration used in previous experiments is Ring-AllReduce that calls for 1-sided (rather than 2-sided) quantization.

Original: We further show that if a high performance computing (HPC) cluster of nodes (with
Revised: We further show that if a high performance computing (HPC) cluster of nodes (with

Original: NVLink high-speed GPU interconnect [Foley and Danskin, 2017]) is used, the communication cost can be further reduced without causing performance loss.
Revised: NVLink high-speed GPU interconnect [Foley and Danskin, 2017]) is used, the communication cost can be further reduced without causing performance loss.

Original:  CONCLUSIONS
Revised:  CONCLUSIONS

Original: We proposed distributed adversarial training (DAT) to scale up the training of adversarially robust DNNs over multiple machines.
Revised: We proposed distributed adversarial training (DAT) to scale up the training of adversarially robust DNNs over multiple machines.

Original: We showed that DAT is general in that it enables large-batch min-max optimization and supports gradient compression and different learning regimes.
Revised: We showed that DAT is general in that it enables large-batch min-max optimization and supports gradient compression and different learning regimes.

Original: We proved that under mild conditions, DAT is guaranteed to converge to a first-order stationary point with a sub-linear rate.
Revised: We proved that under mild conditions, DAT is guaranteed to converge to a ﬁrst-order stationary point with a sub-linear rate.

Original: Empirically, we provided comprehensive experiment results to demonstrate the effectiveness and the usefulness of DAT in training robust DNNs with large datasets and multiple machines.
Revised: Empirically, we provided comprehensive experiment results to demonstrate the effectiveness and the usefulness of DAT in training robust DNNs with large datasets and multiple machines.

Original: In the future, it will be worthwhile to examine the speedup achieved by DAT in the extreme training cases, e.g., using a significantly large number of attack steps and
Revised: In the future, it will be worthwhile to examine the speedup achieved by DAT in the extreme training cases, e.g., using a signiﬁcantly large number of attack steps and

Original: [Table]
Revised: [Table]

Original: distributed machines, and extremely large models.
Revised: distributed machines, and extremely large models.

Original: Acknowledgements
Revised: Acknowledgements

Original: Y. Zhang and S. Liu are supported by the Cisco Research grant CG# 70614511.
Revised: Y. Zhang and S. Liu are supported by the Cisco Research grant CG# 70614511.

Original: P. Khanduri and M. Hong are supported in part by the NSF grants 1910385 and 1727757.
Revised: P. Khanduri and M. Hong are supported in part by the NSF grants 1910385 and 1727757.

Original: We also thank Dr. Cho-Jui Hsieh for the helpful discussion on early ideas of this paper.DAT ALGORITHM FRAMEWORK
Revised: We also thank Dr. Cho-Jui Hsieh for the helpful discussion on early ideas of this paper.

Original: 1: Initial θ 1 , dataset D ( i ) for each of M workers, and T iterations 2: for Iteration t = 1 , 2 , . .

Original: , T do 3: for Worker i = 1 , 2 , . . .

Original: , M do ▷ Worker 4:

Original: Draw a finite-size data batch B it ⊆

Original: D ( i ) 5:

Original: For each data sample x ∈ B it , call for an inner maximization oracle :

Original: [Equation]

Original: A1) where we omit the label or possible pseudo-label y of x for brevity 6:

Original: Computing local gradient of f i in (2) with respect to θ given perturbed samples:

Original: [Equation]

Original: A2) 7: ( Optional ) Call for gradient quantizer Q ( · )

Original: and transmit Q ( g ( i ) t ) to server 8: end for 9:

Original: Gradient aggregation at server: ▷

Original: [Equation]

Original: A

Original: [Equation]

Original: 10: ( Optional ) Call for gradient quantizer ˆ g t ← Q

Original: (ˆ g t ) , and transmit ˆ g t to workers: 11: for Worker i = 1 , 2 , . . .

Original: , M do ▷ Worker 12:

Original: Call for an outer minimization oracle A ( · ) to update θ :

Original: [Equation]

Original: A4) 13: end for 14: end for

Original: Additional details on gradient quantization Let b denote the number of bits ( b ≤ 32 ), and thus there exists s = 2 b quantization levels.

Original: We specify the gradient quantization operation Q ( · ) in Algorithm A1 as the randomized quantizer [Alistarh et al., 2017, Yu et al., 2019].

Original: Formally, the quantization operation at the i th coordinate of a vector g is given by [Alistarh et al., 2017]

Original: [Equation]

Original: In (A5), ξ i ( g i , s ) is a random number drawn as follows.

Original: Given | g i | /

Original: ∥ g ∥ 2 ∈ [ l/s, ( l + 1) /s ] for some l ∈ N + and 0 ≤ l < s , we then have

Original: [Equation]

Original: where | a | denotes the absolute value of a scalar a , and ∥ a ∥ 2 denotes the ℓ 2 norm of a vector a .

Original: The rationale behind using (A5) is that Q ( g i ) is an unbiased estimate of g i , namely, E ξ i ( g i ,s )

Original: [ Q ( g i )]

Original: = g i , with bounded variance.

Original: Moreover, we at most need (32 + d + bd ) bits to transmit the quantized Q ( g ) , where 32 bits for ∥ g ∥ 2 , 1 bit for sign of g i and b bits for ξ i ( g i , s ) , whereas it needs 32 d bits for a single-precision g .

Original: Clearly, a small b saves the communication cost.

Original: We note that if every worker performs as a server in DAT, then the quantization operation at Step 10 of Algorithm A1 is no longer needed.

Original: In this case, the communication network becomes fully connected.

Original: With synchronized communication, this is favored for training DNNs under the All-reduce operation.

Original: THEORETICAL RESULTS

Original: In this section, we will quantify the convergence behaviour of the proposed DAT algorithm.

Original: First, we define the following notations:

Original: [Equation]

Original: We also define

Original: [Equation]

Original: where the label y of x is omitted for labeled data.

Original: Then, the objective function of problem (2) can be expressed in the compact way

Original: [Equation]

Original: and the optimization problem is then given by min θ Ψ( θ ) .

Original: Therefore, it is clear

Original: that if a point θ ⋆ satisfies

Original: [Equation]

Original: then we say θ

Original: ⋆ is a ξ approximate first-order stationary point (FOSP) of problem (2).

Original: Prior to delving into the convergence analysis of DAT, we make the following assumptions.

Original: 2.1 ASSUMPTIONS

Original: A1.

Original: Assume objective function has layer-wise Lipschitz continuous gradients with constant L i for each layer

Original: [Equation]

Original: where ∇ i Ψ( θ · ,i ) denotes the gradient w.r.t.

Original: the variables at the i th layer.

Original: Also, we assume that Ψ( θ ) is lower bounded, i.e., Ψ ⋆ :=

Original: min

Original: θ Ψ( θ ) >

Original: −∞ and bounded gradient estimate, i.e., ∥∇ ˆ g ( i ) t ∥ ≤ G .

Original: A2.

Original: Assume that ϕ ( θ , δ ; x ) is strongly concave with respect to δ with parameter µ and has the following gradient Lipschitz continuity with constant L ϕ :

Original: [Equation]

Original: A3.

Original: Assume that the gradient estimate is unbiased and has bounded variance, i.e.,

Original: [Equation]

Original: where recall that B ( i ) denotes a data batch used at worker i , ∇ θ l ( θ ) :

Original: = 1 M (cid:80) Mi

Original: =1 ∇ θ l i ( θ ) and ∇ θ Φ( θ ) :

Original: = 1 M (cid:80) M i =1 ∇ θ Φ i ( θ ) ; and

Original: [Equation]

Original: Further, we define a component-wise bounded variance of the gradient estimate

Original: [Equation]

Original: where j denotes the index of the layer, and k denotes the index of entry at each layer.

Original: Under A3, we have

Original: [Equation]

Original: A4.

Original: Assume that the component wise compression error has bounded variance

Original: [Equation]

Original: The assumption A4 is satisfied as the randomized quantization is used [Alistarh et al., 2017, Lemma 3.1].

Original: 2.2 ORACLE OF MAXIMIZATION

Original: In practice, Φ i ( θ ; x ) , ∀ i may not be obtained, since the inner loop needs to iterate by the infinite number of iterations to achieve the exact maximum point.

Original: Therefore, we allow some numerical error term resulted in the maximization step at (A1).

Original: This consideration makes the convergence analysis more realistic.

Original: First, we have the following criterion to measure the closeness of the approximate maximizer to the optimal one.

Original: Definition 1.

Original: Under A2, if point δ ( x ) satisfies

Original: [Equation]

Original: then, it is a ε approximate solution to δ ∗ ( x ) , where

Original: [Equation]

Original: and x denotes the sampled data.

Original: Condition (A20) is standard for defining approximate solutions of an optimization problem over a compact feasible set and has been widely studied in [Wang et al., 2019b, Lu et al., 2020].

Original: In the following, we can show that when the inner maximization problem is solved accurately enough, the gradients of function ϕ ( θ , δ ( x ); x ) at δ ( x ) and δ ∗ ( x ) are also close.

Original: A similar claim of this fact has been shown in [Wang et al., 2019b,

Original: Lemma 2].

Original: For completeness of the analysis, we provide the specific statement for our problem here and give the detailed proof as well.

Original: Lemma 1.

Original: Let δ ( k ) t be the ( µε ) /L

Original: 2 ϕ approximate solution of the inner maximization problem for worker k , i.e., max δ ( k ) ϕ

Original: ( θ , δ ( k ) ; x t ) , where x t denotes the sampled data at the t th iteration of DAT.

Original: Under A2, we have

Original: [Equation]

Original: Throughout the convergence analysis, we assume that δ ( k ) t ( x t ) , ∀ k, t are all the ( µε ) /L

Original: 2 ϕ approximate solutions of the inner maximization problem.

Original: Let us define

Original: [Equation]

Original: From Lemma

Original: [Equation]

Original: we know that when δ ( k ) t ( x t ) is a ( µε ) /L

Original: 2 ϕ approximate solution, then

Original: [Equation]

Original: 2.3 FORMAL STATEMENTS OF CONVERGENCE RATE GUARANTEES

Original: In what follows, we provide the formal statement of convergence rate of DAT.

Original: In our analysis, we focus on the 1-sided quantization, namely, Step 10 of Algorithm A1 is omitted, and specify the outer minimization oracle by LAMB [You et al., 2019], see Algorithm A2.

Original: The addition and multiplication operations in LAMB are component-wise.

Original: Theorem 2.

Original: Under A1-A4, suppose that { θ t } is generated by DAT for a total number of T iterations, and let the problem dimension at each layer be d i =

Original: d/h .

Original: Then the convergence rate of DAT is given by

Original: [Equation]

Original: where ∆ Ψ :=

Original: E

Original: [Ψ( θ 1 )] − Ψ ⋆ ] , η t is the learning rate, κ = c u /c l , c l and c u are constants used in LALR (3), χ is an error term with the ( ih + j ) th entry being (cid:113) (1+ λ ) σ 2 ij MB + ε ij + δ 2 ij , ε and ε ij were given in (A24), L =

Original: [ L 1 , . . .

Original: , L h ] T ,

Original: C = 1 4 (cid:113) h (1 − β 2 ) G 2 d , 0 < β 2 < 1 is given in LAMB, B = min {|B ( i ) | , ∀ i } , and G is given in A1.

Original: Remark 1 .

Original: When the batch size is large, i.e., B ∼ √ T , then the gradient estimate error will be O ( σ 2 / √ T ) .

Original: Further, it is worth noting that different from the convergence results of LAMB, there is a linear speedup of deceasing the gradient estimate error in DAT with respect to M , i.e., O ( σ 2 / ( M √ T )) , which is the advantage of using multiple computing nodes.

Original: Remark 2 .

Original: Note that A4 implies E

Original: [( Q ([ g ( k ) ( θ )] ij ) − [ g ( k ) ( θ )] ij ∥ 2 ] ≤ (cid:80) hi

Original: =1 (cid:80) d i j =1 δ 2 ij :=

Original: δ 2 .

Original: From [Alistarh et al., 2017,

Original: Lemma 3.1], we know that δ 2 ≤ min { d/s 2 , √ d/s } G 2 .

Original: Recall that s = 2 b , where b is the number of quantization bits.

Original: Therefore, with a proper choice of the parameters, we can have the following convergence result that has been shown in

Original: Theorem 1.

Original: Corollary 1.

Original: Under the same conditions of Theorem 2, if we choose

Original: [Equation]

Original: we then have

Original: [Equation]

Original: In summary, when the batch size is large enough, DAT converges to a first-order stationary point of problem (2) and there is a linear speed-up in terms of M with respect to σ 2 .

Original: Next, we provide the details of the proof.

Original: PROOF DETAILS 3.1 PRELIMINARIES

Original: In the proof, we use the following inequality and notations.

Original: Young’s inequality with parameter ϵ is

Original: [Equation]

Original: where x , y are two vectors.

Original: Define the historical trajectory of the iterates as F t = { θ t − 1 , . .

Original: , θ 1 } .

Original: We denote vector [ x ] i as the parameters at the i th layer of the neural net and [ x ] ij represents the j th entry of the parameter at the i th layer.

Original: We define

Original: [Equation]

Original: 3.2 DETAILS OF LAMB ALGORITHM

Original: Algorithm A2 LAMB

Original: [You et al., 2019]

Original: Input: learning rate η t , 0 < β 1 , β 2 < 1 , scaling function τ ( · ) , ζ >for t = 1 , . . .

Original: [-do m t = β 1 m t − 1 + (1 − β 1 )ˆ g t , where ˆ g t is given by (A3) v t = β 2 v t − 
-]
Revised: [-do m t = β 1 m t − 1 + (1 − β 1 )ˆ g t , where ˆ g t is given by (A3) v t = β 2 v t − 
-]

Original: + (1 − β 2 )ˆ g 2 t m t = m t / (1 − β t 1 ) v t = v t / (1 − β t 2 )

Original: Compute ratio u t = m t √ v t + ζ end for

Original: Update

Original: [Equation]

Original: A

Original: [Equation]

Original: 3.3 PROOF OF LEMMA

Original: Proof.

Original: From A2, we have (cid:13)(cid:13)(cid:13)

Original: [Equation]

Original: Also, we know that function ϕ

Original: ( θ , δ , x ) is strongly concave with respect to δ , so we have

Original: [Equation]

Original: Next, we have two conditions about the qualities of solutions δ ( i ) t ( x t ) and ( δ ∗ ) ( i ) t ( x t ) .

Original: First, we know that δ ( i ) t ( x t ) is a- ε approximate solution to ( δ ∗ )

Original: ( i ) t ( x t ) , so we have

Original: [Equation]

Original: Second, since ( δ ∗ ) ( i ) t ( x t ) is the optimal solution, it satisfies

Original: [Equation]

Original: Adding them together, we can obtain

Original: [Equation]

Original: Substituting (A35) into (A32), we can get

Original: [Equation]

Original: Combining (A31), we have

Original: [Equation]

Original: 3.4 DESCENT OF QUANTIZED LAMB

Original: First, we provide the following lemma as a stepping stone for the subsequent analysis.

Original: Lemma 2.

Original: Under A1–A3, suppose that sequence { θ t } is generated by DAT.

Original: Then, we have

Original: [Equation]

Original: Proof.

Original: From (A21), (A7) and A2, we know that

Original: [Equation]

Original: so we can get

Original: [Equation]

Original: Then

Original: [Equation]

Original: we have

Original: [Equation]

Original: where

Original: [Equation]

Original: and

Original: [Equation]

Original: Next, we can quantify the different between g t and g ∗ t by gradient Lipschitz continuity of function τ ( · ) as the following

Original: [Equation]

Original: where in ( a ) we use Jensen’s inequality

Original: [Equation]

Original: And the difference between ¯ g t and g ∗ t can be upper bounded by

Original: [Equation]

Original: MB .

Original: [Equation]

Original: Applying Young’s inequality with parameter

Original: [Equation]

Original: we have

Original: [Equation]

Original: [Equation]

Original: 3.5 PROOF OF THEOREM

Original: Proof.

Original: We set β 1 = 0 in LAMB for simplicity.

Original: From gradient Lipschitz continuity, we have

Original: [Equation]

Original: where in ( a ) we use (A30)

Original: [Equation]

Original: and the upper bound of τ ( ∥ θ t,i ∥ )

Original: [Equation]

Original: Next

Original: [Equation]

Original: we split term R as two parts by leveraging sign ([ ∇ Ψ( θ t )] ij ) and sign ([ u t ] ij ) as follows.

Original: [Equation]

Original: where in ( a ) we use the fact

Original: that ∥ u t,i ∥ ≤ (cid:113) d i 1 − β 2 and √ v t ≤ G , and in ( b ) we add

Original: [Equation]

Original: Taking expectation on both sides of (A58)

Original: [Equation]

Original: we have the following:

Original: [Equation]

Original: Next

Original: [Equation]

Original: we will get the upper bounds of U and V separably as follows.

Original: First

Original: [Equation]

Original: we write the inner product between [ ∇ Ψ( θ )] ij and [ˆ g t ] ij more compactly,

Original: [Equation]

Original: Applying Lemma 2, we can get

Original: [Equation]

Original: where we use the in ( a ) we use Young’s inequality (with parameter 2 )

Original: [Equation]

Original: and in ( b ) we have

Original: [Equation]

Original: Second, we give the upper of V :

Original: [Equation]

Original: where the upper bound of W can be quantified by using Markov’s inequality followed by Jensen’s inequality as the following:

Original: [Equation]

Original: where ( a ) is true due to the following relations: i ) from (A51), we have

Original: [Equation]

Original: ii ) from (A49)

Original: , we can get

Original: [Equation]

Original: and iii ) from (A67), we know

Original: [Equation]

Original: Therefore, combining (A55) with the upper bound of U shown in (A66) and V shown in (A68)(A73), we have

Original: [Equation]

Original: Note that the error vector χ is defined as the following

Original: [Equation]

Original: and we have

Original: [Equation]

Original: Recall

Original: [Equation]

Original: Rearranging the terms, we can arrive at

Original: [Equation]

Original: Applying the telescoping sum over t =

Original: [Equation]

Original: [Equation]

Original: T

Original: [Equation]

Original: we have

Original: [Equation]

Original: ADDITIONAL EXPERIMENTS 4.1 TRAINING DETAILS

Original: ImageNet AT and Fast AT experiments are conducted at a single computing node with dual 22-core CPU, 512GB RAM and 6 Nvidia V100 GPUs.

Original: The training epoch is 30 by calling for the momentum SGD optimizer.

Original: The weight decay and momentum parameters are set to 0 . 0001 and 0 .

Original: The initial learning rate is set to 0 .

Original: 1 (tuned over { 0 . 01 , 0 .

Original: 05 , 0 . 1 , 0 . 2 } ), which is decayed by × 1 / 10 at the training epoch 20 , 25 , 28 , respectively.

Original: ImageNet DAT experiments are conducted at { 1 , 3 , 6 } computing nodes with dual 22-core CPU, 512GB RAM and 6 Nvidia

Original: V100 GPUs.

Original: The training epoch is 30 by calling for the LAMB optimizer.

Original: The weight decay is set to 0 . 0001 .

Original: β 1 and β 2 are set to 0 .

Original: 9 and 0 .

Original: The initial learning rate η 1 is tuned over { 0 . 01 , 0 . 05 , 0 . 1 , 0 . 2 , 0 . 4 }, which is decayed by × 1 / 10 at the training epoch 20 , 25 , 28 , respectively.

Original: To execute algorithms with the initial learning rate η 1 greater than 0 .

Original: 2 , we choose the model weights after 5 -epoch warm-up as its initialization for DAT, where each warm-up epoch

Original: k uses the linearly increased learning rate ( k/ 5) η 1 .

Original: 4.2 ADDITIONAL RESULTS

Original: Discussion on cyclic learning rate.

Original: It was shown in [Wong et al., 2020] that the use of a cyclic learning rate (CLR) trick can further accelerate the Fast AT algorithm in the small-batch setting [Wong et al., 2020].

Original: In Figure A1, we present the performance of Fast AT with CLR versus batch sizes.

Original: We observe that when CLR meets the large-batch setting, it becomes significantly worse than its performance in the small-batch setting.

Original: The reason is that CLR requires a certain number of iterations to proceed with the cyclic schedule.

Original: However, the use of large data batch only results in a small amount of iterations by fixing the number of epochs.

Original: Batch Size for Cyclic LR

Original: [Figure]

Original: Additional details on HPC setups.

Original: To further reduce communication cost, we also conduct DAT at a HPC cluster.

Original: The computing nodes of the cluster are connected with InfiniBand (IB) and PCIe Gen4 switch.

Original: To compare with results in

Original: Table 1, we use 6 of 57 nodes of the cluster.

Original: Each node has 6 Nvidia V100s which are interconnected with NVLink.

Original: We use

Original: Nvida NCCL as communication backend.

Original: In Table 4, we have presented the performance of DAT for ImageNet, ResNetwith use of HPC compared to standard (non-HPC) distributed system.