Year: 2019

Abstract:
Deep neural nets (DNNs) compression is crucial for adaptation to mobile devices. Though many successful algorithms exist to compress naturally trained DNNs, developing efficient and stable compression algorithms for robustly trained DNNs remains widely open. In this paper, we focus on a co-design of efficient DNN compression algorithms and sparse neural architectures for robust and accurate deep learning. Such a co-design enables us to advance the goal of accommodating both sparsity and robustness. With this objective in mind, we leverage the relaxed augmented Lagrangian based algorithms to prune the weights of adversarially trained DNNs, at both structured and unstructured levels. Using a Feynman-Kac formalism principled robust and sparse DNNs, we can at least double the channel sparsity of the adversarially trained ResNet20 for CIFAR10 classification, meanwhile, improve the natural accuracy by 8.69% and the robust accuracy under the benchmark 20 iterations of IFGSM attack by 5.42%.

heading: 1 INTRODUCTION
text: Robust deep neural nets (DNNs) compression is a fundamental problem for secure AI applications in resource-constrained environments such as biometric verification and facial login on mobile devices, and computer vision tasks for the internet of things (IoT) (Cheng et al., 2017; Yao et al., 2017; Mohammadi et al., 2018). Though compression and robustness have been separately addressed in recent years, much less is studied when both players are present and must be satisfied.
To date, many successful techniques have been developed to compress naturally trained DNNs, including neural architecture re-design or searching (Howard et al., 2017; Zhang et al., 2018b), pruning including structured (weights sparsification) (Han et al., 2015; Srinivas & Babu, 2015) and unstructured (channel-, filter-, layer-wise sparsification) (Yang et al., 2019; He et al., 2017), quantization (Zhou et al., 2017; Yin et al., 2019; Courbariaux et al., 2016), low-rank approximation (Denil et al., 2013), knowledge distillation (Polino et al., 2018), and many more (Alvarez & Salzmann, 2016; Liu et al., 2015).
The adversarially trained (AT) DNN is more robust than the naturally trained (NT) DNN to adversarial attacks (Madry et al., 2018; Athalye et al., 2018). However, adversarial training (denoted as AT if no ambiguity arises, and the same for NT) also dramatically reduces the sparsity of the trained DNN’s weights. As shown in Fig. 1, start from the same default initialization in PyTorch, the NT ResNet20’s weights are much sparser than that of the AT counterpart, for instance, the percent of
weights that have magnitude less than 10−3 for NT and AT ResNet20 are 8.66% and 3.64% (averaged over 10 trials), resp. This observation motivates us to consider the following two questions:
• 1. Can we re-design the neural architecture with minimal change on top of the existing one such that the new DNN has sparser weights and better robustness and accuracy than the existing one?
• 2. Can we develop efficient compression algorithms to compress the AT DNNs with minimal robustness and accuracy degradations?
We note that under the AT, the recently proposed Feynman-Kac formalism principled ResNet ensemble (Wang et al., 2019a) has much sparser weights than the standard ResNet, which gives a natural answer to the first question above. To answer the second question, we leverage state-of-the-art relaxed augmented Lagrangian based sparsification algorithms (Dinh & Xin, 2018; Yang et al., 2019) to perform both structured and unstructured pruning for the AT DNNs. We focus on unstructured and channel pruning in this work.

heading: 1.1 NOTATION
text: Throughout this paper we use bold upper-case letters A, B to denote matrices, bold lower-case letters x, y to denote vectors, and lower case letters x, y and α, β to denote scalars. For vector x = (x1, . . . , xd) >, we use ‖x‖ = ‖x‖2 = √ x21 + · · ·+ x2d to represent its `2-norm; ‖x‖1 =∑d
i=1 |xi| to represent its `1-norm; and ‖x‖0 = ∑d i=1 χ{xi 6=0} to represent its `0-norm. For a function f : Rd → R, we use ∇f(·) to denote its gradient. Generally, wt represents the set of all parameters of the network being discussed at iteration t, e.g. wt = (wt1,w t 2, ...,w t M ), where w t j is the weight on the jth layer of the network at the t-th iteration. Similarly, ut = (ut1,u t 2, ...,u t M ) is a set of weights with the same dimension as wt, whose value depends on wt and will be defined below. We use N (0, Id×d) to represent the d-dimensional Gaussian, and use notation O(·) to hide only absolute constants which do not depend on any problem parameter.

heading: 1.2 ORGANIZATION
text: This paper is organized in the following way: In section 2, we list the most related work to this paper. In section 3, we show that the weights of the recently proposed Feynman-Kac formalism principled ResNet ensemble are much sparser than that of the baseline ResNet, providing greater efficiency for compression. In section 4, we present relaxed augmented Lagrangian-based algorithms along with theoretical analysis for both unstructured and channeling pruning of AT DNNs. The numerical results are presented in section 5, followed by concluding remarks. Technical proofs and more related results are provided in the appendix.

heading: 2 RELATED WORK
text: Compression of AT DNNs: Gui et al. (2019) considered a low-rank form of the DNN weight matrix with `0 constraints on the matrix factors in the AT setting. Their training algorithm is a projected gradient descent (PGD) (Madry et al., 2018) based on the worst adversary. In their paper, the sparsity in matrix factors are unstructured and require additional memory.
Sparsity and Robustness: Guo et al. (2018) shows that there is a relationship between the sparsity of weights in the DNN and its adversarial robustness. They showed that under certain conditions, sparsity can improve the DNN’s adversarial robustness. The connection between sparsity and robustness has also been studied recently by Ye et al. (2019), Rakin et al. (2019), and et al. In our paper, we focus on designing efficient pruning algorithms integrated with sparse neural architectures to advance DNNs’ sparsity, accuracy, and robustness.
Feynman-Kac formalism principled Robust DNNs: Neural ordinary differential equations (ODEs) (Chen et al., 2018) are a class of DNNs that use an ODE to describe the data flow of each input data. Instead of focusing on modeling the data flow of each individual input data, Wang et al. (2019a; 2018a); Li & Shi (2017) use a transport equation (TE) to model the flow for the whole input distribution. In particular, from the TE viewpoint, Wang et al. (2019a) modeled training ResNet (He
et al., 2016) as finding the optimal control of the following TE ∂u ∂t (x, t) +G(x,w(t)) · ∇u(x, t) = 0, x ∈ R d,
u(x, 1) = g(x), x ∈ Rd, u(xi, 0) = yi, xi ∈ T, with T being the training set.
(1)
where G(x,w(t)) encodes the architecture and weights of the underlying ResNet, u(x, 0) serves as the classifier, g(x) is the output activation of ResNet, and yi is the label of xi.
Wang et al. (2019a) interpreted adversarial vulnerability of ResNet as arising from the irregularity of u(x, 0) of the above TE. To enhance u(x, 0)’s regularity, they added a diffusion term, 12σ
2∆u(x, t), to the governing equation of (1) which resulting in the convection-diffusion equation (CDE). By the Feynman-Kac formula, u(x, 0) of the CDE can be approximated by the following two steps:
• Modify ResNet by injecting Gaussian noise to each residual mapping. • Average the output of n jointly trained modified ResNets, and denote it as EnnResNet.
Wang et al. (2019a) have noticed that EnResNet can improve both natural and robust accuracies of the AT DNNs. In this work, we leverage the sparsity advantage of EnResNet to push the sparsity limit of the AT DNNs.

heading: 3 REGULARITY AND SPARSITY OF THE FEYNMAN-KAC FORMALISM PRINCIPLED ROBUST DNNS’ WEIGHTS
text: From a partial differential equation (PDE) viewpoint, a diffusion term to the governing equation (1) not only smooths u(x, 0), but can also enhance regularity of the velocity field G(x,w(t)) (Ladyženskaja et al., 1988). As a DNN counterpart, we expect that when we plot the weights of EnResNet and ResNet at a randomly select layer, the pattern of the former one will look smoother than the latter one. To validate this, we follow the same AT with the same parameters as that used in (Wang et al., 2019a) to train En5ResNet20 and ResNet20, resp. After the above two robust models are trained, we randomly select and plot the weights of a convolutional layer of ResNet20 whose shape is 64×64×3×3 and plot the weights at the same layer of the first ResNet20 in En5ResNet20. As shown in Fig. 2 (a) and (b), most of En5ResNet20’s weights are close to 0 and they are more regularly distributed in the sense that the neighboring weights are closer to each other than ResNet20’s weights. The complete visualization of this randomly selected layer’s weights is shown in the appendix. As shown in Fig. 2 (c) and (d), the weights of En5ResNet20 are more concentrated at zero than that of ResNet20, and most of the En5ResNet20’s weights are close to zero.

heading: 4 UNSTRUCTURED AND CHANNEL PRUNING WITH AT

heading: 4.1 ALGORITHMS
text: In this subsection, we introduce relaxed, augmented Lagrangian-based, pruning algorithms to sparsify the AT DNNs. The algorithms of interest are the Relaxed Variable-Splitting Method (RVSM) (Dinh & Xin, 2018) for weight pruning (Algorithm 1), and its variation, the Relaxed Group-wise Splitting Method (RGSM) (Yang et al., 2019) for channel pruning (Algorithm 2).
Our approach is to apply the RVSM/RGSM algorithm together with robust PGD training to train and sparsify the model from scratch. Namely, at each iteration, we apply a PGD attack to generate
adversarial images x′, which are then used in the forward-propagation process to generate preditions y′. The back-propagation process will then compute the appropriate loss function and apply RVSM/RGSM to update the model. Previous work on RVSM mainly focused on a one-hidden layer setting; In this paper, we extend this result to the general setting. To the best of our knowledge, this is the first result that uses RVSM/RGSM in an adversarial training scenario.
To explain our choice of algorithm, we discuss a classical algorithm to promote sparsity of the target weights, the alternating direction of multiplier method (ADMM) (Boyd et al., 2011; Goldstein & Osher, 2009). In ADMM, instead of minimizing the original loss function f(w), we seek to minimize the `1 regularized loss function, f(w) + λ‖u‖1, by considering the following augmented Lagrangian
L(w,u, z) = f(w) + λ ‖u‖1 + 〈z,w − u〉+ β
2 ‖w − u‖2, λ, β ≥ 0. (2)
which can be easily solved by applying the following iterations wt+1 ← arg minw Lβ(w,ut, zt) ut+1 ← arg minu Lβ(wt+1,u, zt) zt+1 ← zt + β(wt+1 − ut+1)
(3)
Although widely used in practice, ADMM has several drawbacks when it is used to regularize DNN’s weights. First, one can improve the sparsity of the final learned weights by replacing ‖u‖1 with ‖u‖0; but ‖ · ‖0 is not differentiable, thus current theory of optimization does not apply (Wang et al., 2018b). Second, the update wt+1 ← arg minw Lβ(w,ut, zt) is not a reasonable step in practice, as one has to fully know how f(w) behaves. In most ADMM adaptation on DNN, this step is replaced by a simple gradient descent. Third, the Lagrange multiplier term, 〈z,w − u〉, seeks to close the gap between wt and ut, and this in turn reduces sparsity of ut.
The RVSM we will implement is a relaxation of ADMM. RVSM drops the Lagrangian multiplier, and replaces λ‖u‖1 with λ‖u‖0, and resulting in the following relaxed augmented Lagrangian
Lβ(w,u) = f(w) + λ ‖u‖0 + β
2 ‖w − u‖2. (4)
The above relaxed augmented Lagrangian can be solved efficiently by the iteration in Algorithm 1. RVSM can resolve all the three issues associated with ADMM listed above in training robust DNNs with sparse weights: First, by removing the linear term 〈z,w − u〉, one has a closed form formula for the update of ut without requiring ‖u‖0 to be differentiable. Explicitly, ut = H√
2λ/β (wt) = (wt1χ{|w1|> √ 2λ/β}, ..., w t dχ{|w1|> √ 2λ/β}), where Hα(·) is the hard-
thresholding operator with parameter α. Second, the update of wt is a gradient descent step itself, so the theoretical guarantees will not deviate from practice. Third, without the Lagrange multiplier term zt, there will be a gap between wt and ut at the limit (finally trained DNNs). However, the limit of ut is much sparser than that in the case of ADMM. At the end of each training epoch, we replace wt by ut for the validation process. Numerical results in Section 5 will show that the AT DNN with parameters ut usually outperforms the traditional ADMM in both accuracy and robustness.
Algorithm 1 RVSM Input: η, β, λ, maxepoch, maxbatch Initialization: w0 Define: u0 = H√
2λ/β (w0)
for t = 0, 1, 2, ...,maxepoch do for batch = 1, 2, ...,maxbatch do
wt+1 ← wt − η∇f(wt)− ηβ(wt − ut) ut+1 ← arg minu Lβ(u,wt) = H√2λ/β(w t)
end for end for
Algorithm 2 RGSM Input: η, β, λ1, λ2, maxepoch, maxbatch Objective: f̃(w) = f(w) + λ2‖w‖GL Initialization: Initialize w0, define u0 for g = 1, 2, ..., G do u0g = Proxλ1(w 0 g)
end for for t = 0, 1, 2, ...,maxepoch do
for batch = 1, 2, ...,maxbatch do wt+1 = wt−η∇f̃(wt)−ηβ(wt−ut) for g = 1, 2, ..., G do ut+1g = Proxλ1(w t g)
end for end for
end for
RGSM is a method that generalizes RVSM to structured pruning, in particular, channel pruning. Let w = {w1, ...,wg, ...,wG} be the grouped weights of convolutional layers of a DNN, whereG is the total number of groups. Let Ig be the indices of w in group g. The group Lasso (GLasso) penalty and group-`0 penalty (Yuan & Lin, 2007) are defined as
‖w‖GL := G∑ g=1 ‖wg‖2, ‖w‖G`0 := G∑ g=1 1‖wg‖2 6=0 (5)
and the corresponding Proximal (projection) operators are
ProxGL,λ(wg) := sgn(wg) max(‖wg‖2 − λ, 0), ProxG`0,λ(wg) := wg1‖wg‖2 6= √ 2λ (6)
where sgn(wg) := wg/‖wg‖2. The RGSM method is described in Algorithm 2, which improves on adding group Lasso penalty directly in the objective function (Wen et al., 2016) for natural DNN training (Yang et al., 2019).

heading: 4.2 THEORETICAL GUARANTEES
text: We propose a convergence analysis of the RVSM algorithm to minimize the Lagrangian (4). Consider the following empirical adversarial risk minimization (EARM)
min f∈H
1
n n∑ i=1 max ‖x′i−xi‖∞≤ L(F (x′i,w), yi) (7)
where the classifier F (·,w) is a function in the hypothesis class H, e.g. ResNet and its ensembles, parametrized by w. Here, L(F (xi,w), yi) is the appropriate loss function associated with F on the data-label pair (xi, yi), e.g. cross-entropy for classification and root mean square error for regression problem. Since our model is trained using PGD AT, let
f(w) = E(x,y)∼D[max x′
L(F (x′,w), y)] (8)
where x′ is obtained by applying the PGD attack to the clean data x (Wang et al., 2019a; Goodfellow et al., 2014a; Madry et al., 2018; Na et al., 2018). In a nutshell, f(w) is the population adversarial loss of the network parameterized by w = (w1,w2, ...,wM ). Before proceeding, we first make the following assumption:
Assumption 1. Let w1,w2, ...,wM be the weights in the M layers of the given DNN, then there exists a positive constant L such that for all t,
‖∇f(·,wt+1j , ·)−∇f(·,w t j , ·)‖ ≤ L‖wt+1j −w t j‖, for j = 1, 2, · · · ,M. (9)
Assumption 1 is a weaker version of that made by Wang et al. (2019b); Sinha et al. (2018), in which the empirical adversarial loss function is smooth in both the input x and the parameters w. Here we only require the population adversarial loss f to be smooth in each layer of the DNN in the region of iterations. An important consequence of Assumption 1 is
f(·,wt+1j , ·)− f(·,w t j , ·) ≤ 〈∇f(·,wtj , ·), (0, ...,wt+1j −w t j , 0, ...)〉+
L 2 ‖wt+1j −w t j‖2 (10)
Theorem 1. Under the Assumption 1, suppose also that the RVSM algorithm is initiated with a small stepsize η such that η < 2β+L . Then the Lagrangian Lβ(w
t,ut) decreases monotonically and converges sub-sequentially to a limit point (w̄, ū).
The proof of Theorem 1 is provided in the Appendix. From the descent property of Lβ(wt,ut), classical results from optimization (Nesterov, 2014) can be used to show that after T = O(1/ 2) iterations, we have ∇wtLβ(wt,ut) = O( ), for some t ∈ (0, T ]. The term ‖u‖0 promotes sparsity and β2 ‖w − u‖ 2 helps keep w close to u. Since u = H√ 2λ/β
(w), it follows that w̄ will have lots of very small (and thus negligible) components. This result justifies the sparsity in the limit ū.

heading: 5 NUMERICAL RESULTS
text: In this section, we verify the following advantages of the proposed algorithms:
• RVSM/RGSM is efficient for unstructured/channel-wise pruning for the AT DNNs. • After pruning by RVSM and RGSM, EnResNet’s weights are significantly sparser than the base-
line ResNet’s, and more accurate in classifying both natural and adversarial images.
These two merits lead to the fact that a synergistic integration of RVSM/RGSM with the FeynmanKac formula principled EnResNet enables sparsity to meet robustness.
We perform AT by PGD integrated with RVSM, RGSM, or other sparsification algorithms on-thefly. For all the experiments below, we run 200 epochs of the PGD (10 iterations of the iterative fast gradient sign method (IFGSM10) with α = 2/255 and = 8/255, and an initial random perturbation of magnitude ). The initial learning rate of 0.1 decays by a factor of 10 at the 80th, 120th, and 160th epochs, and the RVSM/RGSM/ADMM sparsification takes place in the back-propagation stage. We split the training data into 45K/5K for training and validation, and the model with the best validation accuracy is used for testing. We test the trained models on the clean images and attack them by FGSM, IFGSM20, and C&W with the same parameters as that used in (Wang et al., 2019a; Zhang et al., 2019; Madry et al., 2018). We denote the accuracy on the clean images and under the FGSM, IFGSM20 (Goodfellow et al., 2014b), C&W (Carlini & Wagner, 2016), and NAttack (Li et al., 2019) 1 attacks as A1, A2, A3, A4, and A5, resp. A brief introduction of these attacks is available in the appendix. We use both sparsity and channel sparsity to measure the performance of the pruning algorithms, where the sparsity is defined to be the percentage of zero weights; the channel sparsity is the percentage of channels whose weights’ `2 norm is less than 1E − 15.

heading: 5.1 MODEL COMPRESSION FOR AT RESNET AND ENRESNETS
text: First, we show that RVSM is efficient to sparsify ResNet and EnResNet. Table 1 shows the accuracies of ResNet20 and En2ResNet20 under the unstructured sparsification with different sparsity controlling parameter β. We see that after the unstructured pruning by RVSM, En2ResNet20 has much sparser weights than ResNet20. Moreover, the sparsified En2ResNet20 is remarkably more accurate and robust than ResNet20. For instance, when β = 0.5, En2ResNet20’s weights are 16.42% sparser than ResNet20’s (56.34% vs. 39.92%). Meanwhile, En2ResNet20 boost the natural and robust accuracies of ResNet20 from 74.08%, 50.64%, 46.67%, and 57.24% to 78.47%, 56.13%, 49.54%, and 65.57%, resp. We perform a few independent trials, and the random effects is small.
Second, we verify the effectiveness of RGSM in channel pruning. We lists the accuracy and channel sparsity of ResNet20, En2ResNet20, and En5ResNet20 in Table 2. Without any sparsification, En2ResNet20 improves the four type of accuracies by 4.27% (76.07% vs. 80.34%), 5.87% (51.24% vs. 57.11%), 2.77% (47.25% vs. 50.02%), and 7.47% (59.30% vs. 66.77%), resp. When we set β = 1, λ1 = 5e − 2, and λ2 = 1e − 5, after channel pruning both natural and robust accuracies of ResNet20 and En2ResNet20 remain close to the unsparsified models, but En2ResNet20’s weights are 33.48% (41.48% vs. 8%) sparser than that of ResNet20’s. When we increase the channel sparsity level by increasing λ1 to 1e−1, both the accuracy and channel sparsity gaps between ResNet20 and
1For NAttack, we use the default parameters in https://github.com/cmhcbb/attackbox.
En2ResNet20 are enlarged. En5ResNet20 can future improve both natural and robust accuracies on top of En2ResNet20. For instance, at ∼ 55% (53.36% vs. 56.74%) channel sparsity, En5ResNet20 can improve the four types of accuracy of En2ResNet20 by 4.66% (80.53% vs. 75.87%), 2.73% (57.38% vs. 54.65%), 2.86% (50.63% vs. 47.77%), and 1.11% (66.52% vs. 65.41%), resp.
Third, we show that an ensemble of small ResNets via the Feynman-Kac formalism performs better than a larger ResNet of roughly the same size in accuracy, robustness, and sparsity. We AT En2ResNet20 (∼ 0.54M parameters) and ResNet38 (∼ 0.56M parameters) with and without channel pruning. As shown in Table 3, under different sets of parameters, after RGSM pruning, En2ResNet20 always has much more channel sparsity than ResNet38, also much more accurate and robust. For instance, when we set β = 1, λ1 = 5e − 2, and λ2 = 1e − 5, the AT ResNet38 and En2ResNet20 with channel pruning have channel sparsity 17.67% and 41.48%, resp. Meanwhile, En2ResNet20 outperforms ResNet38 in the four types of accuracy by 0.36% (78.28% vs. 77.92%), 3.02% (56.53% vs. 53.51%), 0.23% (49.58% vs. 49.35%), and 6.34% (66.56% vs. 60.32%), resp. When we increase λ1, the channel sparsity of two nets increase.. As shown in Fig. 3, En2ResNet20’s channel sparsity growth much faster than ResNet38’s, and we plot the corresponding four types of accuracies of the channel sparsified nets in Fig. 4.
Table 3: Performance of En2ResNet20 and ResNet38 under RVSM.
Net β λ1 λ2 A1 A2 A3 A4 Ch. Sp.
En2ResNet20 n/a n/a n/a 80.34 57.11 50.02 66.77 0 ResNet38 n/a n/a n/a 78.03 54.09 49.81 61.72 0
En2ResNet20 1 5.E-02 1.E-05 78.28 56.53 49.58 66.56 41.48 ResNet38 1 5.E-02 1.E-05 77.92 53.51 49.35 60.32 17.67
En2ResNet20 1 1.E-01 1.E-05 76.30 54.65 47.77 65.41 56.74 ResNet38 1 1.E-01 1.E-05 72.95 49.78 46.48 57.92 43.80
0 0.02 0.04 0.06 6
1
76
78
80
82
A 1
En 2 ResNet20 ResNet38 0 0.02 0.04 0.06
6 1
52
54
56
58
A 2
En 2 ResNet20 ResNet38
0 0.02 0.04 0.06 6
1
48.5
49
49.5
50
50.5
A 3
En 2 ResNet20 ResNet38
0 0.02 0.04 0.06 6
1
55
60
65
70
A 4
En 2 ResNet20 ResNet38
Figure 4: Accuracy of En2ResNet20 and ResNet38 under different parameters λ1. (5 runs)

heading: 5.2 RVSM/RGSM VERSUS ADMM
text: In this subsection, we will compare RVSM, RGSM, and ADMM (Zhang et al., 2018a) 2 for unstructured and channel pruning for the AT ResNet20, and we will show that RVSM and RGSM iterations can promote much higher sparsity with less natural and robust accuracies degradations than ADMM. We list both natural/robust accuracies and sparsities of ResNet20 after ADMM, RVSM, and RGSM pruning in Table 4. For unstructured pruning, ADMM retains slightly better natural (∼ 1.3%) and robust (∼ 0.7%, ∼ 0.5%, and 0.2% under FGSM, IFGSM20, and C&W attacks) accuracies. However, RVSM gives much better sparsity (80.91% vs. 10.89%). In the channel pruning scenario, RVSM significantly outperforms ADMM in all criterion including natural and robust accuracies and channel sparsity, as the accuracy gets improved by at least 5.19% and boost the channel sparsity from 4.44% to 25.33%. Part of the reason for ADMM’s inefficiency in sparsifying DNN’s weights is due to the fact that the ADMM iterations try to close the gap between the weights wt and the auxiliary variables ut, so the final result has a lot of weights with small magnitude, but not small enough to be regarded as zero (having norm less than 1e-15). The RVSM does not seek to close this gap, instead it replaces the weight wt by ut, which is sparse, after each epoch. This results in a much sparser final result, as shown in Figure 5: ADMM does result in a lot of channels with small norms; but to completely prune these off, RVSM does a better job. Here, the channel norm is defined to be the `2 norm of the weights in each channel of the DNN (Wen et al., 2016).

heading: 5.3 BEYOND RESNET ENSEMBLE AND BEYOND CIFAR10

heading: 5.4 BEYOND RESNET ENSEMBLE
text: In this part, we show that the idea of average over noise injected ResNet generalizes to other types of DNNs, that is, the natural and robust accuracies of DNNs can be improved by averaging over noise injections. As a proof of concept, we remove all the skipping connections in ResNet20 and
2We use the code from: github.com/KaiqiZhang/admm-pruning
En2ResNet20, in this case, the model no longer involves a TE and CDE. As shown in Table 5, removing the skip connection degrades the performance significantly, especially for En2ResNet20 (all the four accuracies of the AT En2ResNet20 reduces more than the AT ResNet20’s). These results confirm that skip connection is crucial, without it the TE model assumption breaks down, and the utility of EnResNets reduces. However, the ensemble of noise injected DNNs still improves the performance remarkably.
Next, let us consider the sparsity, robustness, and accuracies of ResNet20 and En2ResNet20 without any skip connection, when they are AT using weights sparsification by either RVSM or RGSM. For RVSM pruning, we set β = 5E − 2 and λ = 1E − 6; for RGSM channel pruning, we set β = 5E − 2, λ1 = 5E − 2, and λ2 = 1E − 5. We list the corresponding results in Table 6. We see that under both RVSM and RGSM pruning, En2ResNet20 is remarkably more accurate on both clean and adversarial images, and significantly sparser than ResNet20. When we compare the results in Table 6 with that in Tables 1 and 2, we conclude that once we remove the skip connections, the sparsity, robustness, and accuracy degrades dramatically.

heading: 5.5 BEYOND CIFAR10
text: Besides CIFAR10, we further show the advantage of EnResNet + RVSM/RGSM in compressing and improving accuracy/robustness of the AT DNNs for CIFAR100 classification. We list the natural and robust accuracies and channel sparsities of the AT ResNet20 and En2ResNet20 with different RGSM parameters (n/a stands for do not perform channel pruning) in Table 7. For λ1 = 0.05, RGSM almost preserves the performance of the DNNs without channel pruning, while improving channel sparsity by 7.11% for ResNet20, and 16.89% for En2ResNet20. As we increase λ1 to 0.1, the channel sparsity becomes 18.37% for ResNet20 and 39.23% for En2ResNet20. Without any channel pruning, En2ResNet20 improves natural accuracy by 4.66% (50.68% vs. 46.02%), and robust accuracies by 5.25% (30.2% vs. 24.77%), 3.02% (26.25% vs. 23.23%), and 7.64% (40.06% vs. 32.42%), resp., under the FGSM, IFGSM20, and C&W attacks. Even in very high channel sparsity scenario (λ1 = 0.05), En2ResNet20 still dramatically increase A1, A2, A3, and A4 by 2.90%, 4.31%, 1.89%, and 5.86%, resp. These results are similar to the one obtained on the CIFAR10 in Table 2. These results further confirm that RGSM together with the Feynman-Kac formalism principled ResNets ensemble can significantly improve both natural/robust accuracy and sparsity on top of the baseline ResNets.

heading: 6 CONCLUDING REMARKS
text: The Feynman-Kac formalism principled AT EnResNet’s weights are much sparser than the baseline ResNet’s. Together with the relaxed augmented Lagrangian based unstructured/channel pruning
algorithms, we can compress the AT DNNs much more efficiently, meanwhile significantly improves both natural and robust accuracies of the compressed model. As future directions, we propose to quantize EnResNets and to integrate neural ODE into our framework.

heading: A PROOF OF THEOREM 1
text: By the arg min update of ut, Lβ(wt+1,ut+1) ≤ Lβ(wt+1,ut). It remains to show Lβ(wt+1,ut) ≤ Lβ(wt,ut). To this end, we show
Lβ(wt+11 ,wt2, ...,wtM ,ut) ≤ Lβ(wt1,wt2, ...,wtM ,ut)
the conclusion then follows by a repeated argument. Notice the only change occurs in the first layer wt1. For simplicity of notation, only for the following chain of inequality, let w t = (wt1, ...,w t M ) and wt+1 = (wt+11 ,w t 2, ...,w t M ). Then for a fixed u := u t, we have
Lβ(wt+1,u)− Lβ(wt,u)
=f(wt+1)− f(wt) + β 2
( ‖wt+1 − u‖2 − ‖wt − u‖2 ) ≤〈∇f(wt),wt+1 −wt〉+ L
2 ‖wt+1 −wt‖2 + β 2
( ‖wt+1 − u‖2 − ‖wt − u‖2 ) = 1
η 〈wt −wt+1,wt+1 −wt〉 − β〈wt − u,wt+1 −wt〉
+ L 2 ‖wt+1 −wt‖2 + β 2
( ‖wt+1 − u‖2 − ‖wt − u‖2 ) = 1
η 〈wt −wt+1,wt+1 −wt〉+
( L
2 + β 2
) ‖wt+1 −wt‖2
+ β 2 ‖wt+1 − u‖2 − β 2 ‖wt − u‖2 − β〈wt − u,wt+1 −wt〉 − β 2 ‖wt+1 −wt‖2
=
( L
2 + β 2 − 1 η
) ‖wt+1 −wt‖2
Thus, when η ≤ 2β+L , we have Lβ(w t+1,u) ≤ Lβ(wt,u). Apply the above argument repeatedly, we arrive at
Lβ(wt+1,ut+1) ≤ Lβ(wt+1,ut) ≤ Lβ(wt+11 ,w t+1 2 , ...,w t+1 M−1,w t M ,u t) ≤ ... ≤ Lβ(wt,ut)
This implies Lβ(wt,ut) decreases monotonically. Since Lβ(wt,ut) ≥ 0, (wt,ut) must converge sub-sequentially to a limit point (w̄, ū). This completes the proof.

heading: B ADVERSARIAL ATTACKS USED IN THIS WORK
text: We focus on the `∞ norm based untargeted attack. For a given image-label pair {x, y}, a given ML model F (x,w), and the associated loss L(x, y) := L(F (x,w), y):
• Fast gradient sign method (FGSM) searches an adversarial, x′, within an `∞-ball as
x′ = x + · sign (∇xL(x, y)) .
• Iterative FGSM (IFGSMM ) (Goodfellow et al., 2014b) iterates FGSM and clip the range as
x(m) = Clipx,
{ x(m−1) + α · sign ( ∇x(m−1)L(x(m−1), y) )} , w/ x(0) = x, m = 1, · · · ,M.
• C&W attack (Carlini & Wagner, 2016) searches the minimal perturbation (δ) attack as
min δ ||δ||∞, subject to F (w,x + δ) = t, x + δ ∈ [0, 1]d, for ∀t 6= y.
• NAttack (Li et al., 2019) is an effective gradient-free attack.

heading: C MORE VISUALIZATIONS OF THE DNNS’ WEIGHTS
text: In section 3, we showed some visualization results for part of the weights of a randomly selected convolutional layer of the AT ResNet20 and En5ResNet20. The complete visualization results of this selected layer are shown in Figs. 6 and 7, resp., for ResNet20 and En5ResNet20. These plots further verifies that:
• The magnitude of the weights of the adversarially trained En5ResNet20 is significantly smaller than that of the robustly trained ResNet20.
• The overall pattern of the weights of the adversarially trained En5ResNet20 is more regular than that of the robustly trained ResNet20.

Review summaries:
This paper focuses on the study of sparse neural architectures and efficient DNN compression algorithms for the robust and accurate deep learning. The authors apply relaxed augmented Lagrangian based sparsification algorithms to perform both unstructured and channel pruning for the AT DNNs. By combing with the sparsity merit of EnResNet, their sparsification algorithms further boost the sparsity limit of the AT DNNs, leading to much better robustness and accuracy. Their approach demonstrates superior natural and robust accuracies under several benchmark attacks.