A D V -BNN : I MPROVED A DVERSARIAL D EFENSE THROUGH R OBUST B AYESIAN N EURAL N ETWORK
A BSTRACT
We present a new algorithm to train a robust neural network against adversarial attacks.
Our algorithm is motivated by the following two ideas.
First, although recent work has demonstrated that fusing randomness can improve the robustness of neural networks (Liu et al., 2017), we noticed that adding noise blindly to all the layers is not the optimal way to incorporate randomness.
Instead, we model randomness under the framework of Bayesian Neural Network (BNN) to formally learn the posterior distribution of models in a scalable way.
Second, we formulate the mini-max problem in BNN to learn the best model distribution under adversarial attacks, leading to an adversarial-trained Bayesian neural network.
Experiment results demonstrate that the proposed algorithm achieves state-of-the-art performance under strong attacks.
On CIFAR-10 with VGG network, our model leads to 14% accuracy improvement compared with adversarial training (Madry et al., 2017) and random self-ensemble (Liu et al., 2017) under PGD attack with 0 .distortion, and the gap becomes even larger on a subset of ImageNet 1 .
I NTRODUCTION
Deep neural networks have demonstrated state-of-the-art performances on many difﬁcult machine learning tasks.
Despite the fundamental breakthroughs in various tasks, deep neural networks have been shown to be utterly vulnerable to adversarial attacks (Szegedy et al., 2013; Goodfellow et al., 2015).
Carefully crafted perturbations can be added to the inputs of the targeted model to drive the performances of deep neural networks to chance-level.
In the context of image classiﬁcation, these perturbations are imperceptible to human eyes but can change the prediction of the classiﬁcation model to the wrong class.
Algorithms seek to ﬁnd such perturbations are denoted as adversarial attacks (Chen et al., 2018; Carlini & Wagner, 2017b; Papernot et al., 2017), and some attacks are still effective in the physical world (Kurakin et al., 2017; Evtimov et al., 2017).
The inherent weakness of lacking robustness to adversarial examples for deep neural networks brings out security concerns, especially for security-sensitive applications which require strong reliability.
To defend from adversarial examples and improve the robustness of neural networks, many algorithms have been recently proposed (Papernot et al., 2016; Zantedeschi et al., 2017; Kurakin et al., 2017; Huang et al., 2015; Xu et al., 2015).
Among them, there are two lines of work showing effective results on medium-sized data (e.g., CIFAR-10).
The ﬁrst line of work uses adversarial training to improve robustness, and the recent algorithm proposed in Madry et al.
(2017) has been recognized as one of the most successful defenses, as shown in Athalye et al.
The second line of work adds stochastic components in the neural network to hide gradient information from attackers.
In the black-box setting, stochastic outputs can signiﬁcantly increase query counts for attacks using ﬁnite-difference techniques (Chen et al., 2018; Ilyas et al., 2018), and even in the white-box setting the recent Random Self-Ensemble (RSE) approach proposed by Liu et al.
(2017) achieves similar performance to Madry’s adversarial training algorithm.
In this paper, we propose a new defense algorithm called Adv-BNN.
The idea is to combine adversarial training and Bayesian network, although trying BNNs in adversarial attacks is not new (e.g.
(Li & Gal, 2017; Feinman et al., 2017; Smith & Gal, 2018)), and very recently Ye & Zhu (2018) also tried to combine Bayesian learning with adversarial training, this is the ﬁrst time we scale the problem to complex data and our approach achieves better robustness than previous defense methods.
The contributions of this paper can be summarized below:
• Instead of adding randomness to the input of each layer (as what has been done in RSE), we directly assume all the weights in the network are stochastic and conduct training with techniques commonly used in Bayesian Neural Network (BNN).
• We propose a new mini-max formulation to combine adversarial training with BNN, and show the problem can be solved by alternating between projected gradient descent and SGD.
• We test the proposed Adv-BNN approach on CIFAR10, STL10 and ImageNet143 datasets, and show signiﬁcant improvement over previous approaches including RSE and adversarial training.
Notations A neural network parameterized by weights w ∈ R d is denoted by f ( x ; w ) , where x ∈ R p is an input example and y is the corresponding label, the training/testing dataset is D tr / te with size N tr / te respectively.
When necessary, we abuse D tr / te to deﬁne the empirical distributions, i.e. D tr / te =
[Equation]
δ ( x i ) δ ( y i ) , where δ ( · ) is the Dirac delta function.
x o represents the original input and x adv denotes the adversarial example.
The loss function is represented as (cid:96) (cid:0) f
( x i ; w ) , y i (cid:1) , where i is the index of the data point.
Our approach works for any loss but we consider the cross-entropy loss in all the experiments.
The adversarial perturbation is denoted as ξ ∈ R p , and adversarial example is generated by x adv = x o + ξ .
In this paper, we focus on the attack under norm constraint Madry et al.
(2017), so that (cid:107) ξ (cid:107) ≤ γ .
In order to align with the previous works, in the experiments we set the norm to (cid:107) · (cid:107) ∞ .
The Hadamard product is denoted as (cid:12) .
B ACKGROUNDS 2. A DVERSARIAL ATTACK AND DEFENSE
In this section, we summarize related works on adversarial attack and defense.
Attack: Most algorithms generate adversarial examples based on the gradient of loss function with respect to the inputs.
For example, FGSM (Goodfellow et al., 2015) perturbs an example by the sign of gradient, and use a step size to control the (cid:96) ∞ norm of perturbation.
Kurakin et al.
(2017) proposes to run multiple iterations of FGSM.
More recently, C&W attack Carlini & Wagner (2017a) formally poses attack as an optimization problem, and applies a gradient-based iterative solver to get an adversarial example.
Both C&W attack and PGD attack (Madry et al., 2017) have been frequently used to benchmark the defense algorithms due to their effectiveness (Athalye et al., 2018).
Throughout, we take the PGD attack as an example, largely following Madry et al.
The goal of PGD attack is to ﬁnd adversarial examples in a γ -ball, which can be naturally formulated as the following objective function:
[Equation]
) , y o ) . [Equation] Starting from x 0 = x o , PGD attack conducts projected gradient descent iteratively to update the adversarial example:
[Equation]
where Π γ is the projection to the set { x | (cid:107) x − x o (cid:107) ∞ ≤ γ } .
Although multi-step PGD iterations may not necessarily return the optimal adversarial examples, we decided to apply it in our experiments, following the previous work of (Madry et al., 2017).
An advantage of PGD attack over C&W attack is that it gives us a direct control of distortion by changing γ , while in C&W attack we can only do this indirectly via tuning the regularizer.
Since we are dealing with networks with random weights, we elaborate more on which strategy should attackers take to increase their success rate, and the details can be found in Athalye et al.
In random neural networks, an attacker seeks a universal distortion ξ that cheats a majority of realizations of the random weights.
This can be achieved by maximizing the loss expectation
[Equation]
Here the model weights w are considered as random vector following certain distributions.
In fact, solving (3) to a saddle point can be done easily by performing multi-step (projected) SGD updates.
This is done inherently in some iterative attacks such as C&W or PGD discussed above, where the only difference is that we sample new weights w at each iteration.
Defense: There are a large variety of defense methods proposed in recent years, e.g. denoiser based
HGD (Liao et al., 2017) and randomized image preprocessing (Xie et al., 2017).
Readers can ﬁnd more from Kurakin et al.
Below we select two representative ones that turn out to be effective to white box attacks.
They are the major baselines in our experiments.
The ﬁrst example is the adversarial training (Szegedy et al., 2013; Goodfellow et al., 2015).
It is essentially a data augmentation method, which trains the deep neural networks on adversarial examples until the loss converges.
Instead of searching for adversarial examples and adding them into the training data, Madry et al.
(2017) proposed to incorporate the adversarial search inside the training process, by solving the following robust optimization problem:
[Equation]
where D tr is the training data distribution.
The above problem is approximately solved by generating adversarial examples using PGD attack and then minimizing the classiﬁcation loss of the adversarial example.
In this paper, we propose to incorporate adversarial training in Bayesian neural network to achieve better robustness.
The other example is RSE (Liu et al., 2017), in this algorithm the authors proposed a “noise layer”, which fuses input features with Gaussian noise.
They show empirically that an ensemble of models can increase the robustness of deep neural networks.
Besides, their method can generate an inﬁnite number of models on-the-ﬂy without any additional memory cost.
The noise layer is applied in both training and testing phases, so the prediction accuracy will not be largely affected.
Our algorithm is different from RSE in two folds: 1) We add noise to each weight instead of input or hidden feature, and formally model it as a BNN.
We incorporate adversarial training to further improve the performance.
2. B AYESIAN N EURAL N ETWORKS (BNN)
[Figure]
The idea of BNN is illustrated in Fig.
Given the observable random variables ( x , y ) , we aim to estimate the distributions of hidden variables w .
In our case, the observable random variables correspond to the features x and labels y , and we are interested in the posterior over the weights p ( w | x , y ) given the prior p ( w ) .
However, the exact solution of posterior is often intractable: notice that p ( w | x , y ) =
p ( x ,y | w ) p ( w ) p ( x ,y )
but the denominator involves a high dimensional integral (Blei et al., 2017), hence the conditional probabilities are hard to compute.
To speedup inference, we generally have two approaches—we can either sample w ∼ p ( w | x , y ) efﬁciently without knowing the closed-form formula through, for example, Stochastic
Gradient Langevin Dynamics (SGLD)
(Welling & Teh, 2011), or we can approximate the true posterior p ( w | x , y ) by a parametric distribution q θ ( w ) , where the unknown parameter θ is estimated by minimizing KL (cid:0) q θ ( w ) (cid:107) p ( w | x , y ) (cid:1) over θ .
For neural network, the exact form of KL-divergence can be unobtainable, but we can easily ﬁnd an unbiased gradient estimator of it using backward propagation, namely Bayes by Backprop (Blundell et al., 2015).
Despite that both methods are widely used and analyzed in-depth, they have some obvious shortcomings, making high dimensional Bayesian inference remain to be an open problem.
For SGLD and its extension (e.g. (Li et al., 2016)), since the algorithms are essentially SGD updates with extra Gaussian noise, they are very easy to implement.
However, they can only get one sample w ∼ p ( w | x , y ) in each minibatch iteration at the cost of one forward-backward propagation, thus not efﬁcient enough for fast inference.
In addition, as the step size η t in SGLD decreases, the samples become more and more correlated so that one needs to generate many samples in order to control the variance.
Conversely, the variational inference method is efﬁcient to generate samples since we know the approximated posterior q θ ( w ) once we minimized the KL-divergence.
The problem is that for simplicity we often assume the approximation q θ to be a fully factorized Gaussian distribution:
[Equation]
Although our assumption (5) has a simple form, it inherits the main drawback from mean-ﬁeld approximation.
When the ground truth posterior has signiﬁcant correlation between variables, the approximation in (5) will have a large deviation from true posterior p ( w | x , y ) .
This is especially true for convolutional neural networks, where the values in the same convolutional kernel seem to be highly correlated.
However, we still choose this family of distribution in our design as the simplicity and efﬁciency are mostly concerned.
In fact, there are many techniques in deep learning area borrowing the idea of Bayesian inference without mentioning explicitly.
For example, Dropout (Srivastava et al., 2014) is regarded as a powerful regularization tool for deep neural networks, which applies an element-wise product of the feature maps and i.i.d.
Bernoulli or Gaussian r.v. B (1 , α ) (or N (1 , α ) )
If we allow each dimension to have an independent dropout rate and take them as model parameters to be learned, then we can extend it to the variational dropout method (Kingma et al., 2015).
Notably, learning the optimal dropout rates for data relieves us from manually tuning hyper-parameter on hold-out data.
Similar idea is also used in RSE (Liu et al., 2017), except that it was used to improve the robustness under adversarial attacks.
As we discussed in the previous section, RSE incorporates Gaussian noise (cid:15) ∼ N (0 , σ 2 ) in an additive manner, where the variance σ 2 is user predeﬁned in order to maximize the performance.
Different from RSE, our Adv-BNN has two degrees of freedom (mean and variance) and the network is trained on adversarial examples.
M ETHOD
In our method, we combine the idea of adversarial training (Madry et al., 2017) with Bayesian neural network, hoping that the randomness in the weights w provides stronger protection for our model.
To build our Bayesian neural network, we assume the joint distribution q µ , s ( w ) is fully factorizable (see (5)), and each posterior q µ i , s i ( w i ) follows normal distribution with mean µ i and standard deviation exp( s i ) >
The prior distribution is simply isometric Gaussian N ( 0 d , s 20 I d × d ) .
We choose the Gaussian prior and posterior for its simplicity and closed-form KL-divergence, that is, for any two Gaussian distributions s and t ,
[Equation]
s or t
[Equation]
σ 2 s or t ) .
[Equation]
Note that it is also possible to choose more complex priors such as “spike-and-slab” (Ishwaran et al., 2005) or Gaussian mixture, although in these cases the KL-divergence of prior and posterior is hard to compute and practically we replace it with the Monte-Carlo estimator, which has higher variance, resulting in slower convergence rate (Kingma, 2017).
Following the recipe of variational inference, we adapt the robust optimization to the evidence lower bound (ELBO) w.r.t.
the variational parameters during training.
First of all, recall the ELBO on the original dataset (the unperturbed data) can be written as
[Equation]
rather than directly maximizing the ELBO in (7), we consider the following alternative objective,
[Equation]
This is essentially ﬁnding the minima for each data point ( x i , y i )
∈ D tr inside the γ -norm ball, we can also interpret (8) as an even looser lower bound of evidence.
So the robust optimization procedure is to maximize (8), i
[Equation]
e.
[Equation]
To make the objective more speciﬁc
[Equation]
we combine (8) with (9) and get
[Equation]
In our case, p ( y | x adv , w ) =
Softmax (cid:0) f
( x adv i ; w ) (cid:1) [ y i ] is the network output on the adversarial sample ( x adv i , y i ) .
More generally, we can reformulate our model as y = f
( x ; w )+ ζ and assume the residual ζ follows either Logistic(0 , 1) or Gaussian distribution depending on the speciﬁc problem, so that our framework includes both classiﬁcation and regression tasks.
We can see that the only difference between our Adv-BNN and the standard BNN training is that the expectation is now taken over the adversarial examples ( x adv , y ) , rather than natural examples ( x , y ) .
Therefore, at each iteration we ﬁrst apply a randomized PGD attack (as introduced in eq (3)) for T iterations to ﬁnd x adv , and then ﬁx the x adv to update µ , s .
When updating µ and s , the KL term in (8) can be calculated exactly by (6), whereas the second term is very complex (for neural networks) and can only be approximated by sampling.
Besides, in order to ﬁt into the back-propagation framework, we adopt the Bayes by Backprop algorithm (Blundell et al., 2015).
Notice that we can reparameterize w = µ + exp( s ) (cid:12) (cid:15) , where (cid:15) ∼ N ( 0 d , I d × d ) is a parameter free random vector, then for any differentiable function h ( w , µ , s ) , we can show that
[Equation]
Now the randomness is decoupled from model parameters, and thus we can generate multiple (cid:15) to form a unbiased gradient estimator.
To integrate into deep learning framework more easily, we also designed a new layer called RandLayer , which is summarized in appendix.
It is worth noting that once we assume the simple form of variational distribution (5), we can also adopt the local reparameterization trick (Kingma et al., 2015).
That is, rather than sampling the weights w , we directly sample the activations and enjoy the lower variance during the sampling process.
Although in our experiments we ﬁnd the simple Bayes by Backprop method efﬁcient enough.
For ease of doing SGD iterations, we rewrite (9) into a ﬁnite sum problem by dividing both sides by the number of training samples N
[Equation]
here we deﬁne g ( µ , s ) (cid:44) KL ( q µ , s ( w ) (cid:107) p ( w )) by the closed form solution (6), so there is no randomness in it.
We sample new weights by w = µ + exp( s ) (cid:12) (cid:15) in each forward propagation, so that the stochastic gradient is unbiased.
In practice, however, we need a weaker regularization for small dataset or large model, since the original regularization in (12) can be too large.
We ﬁx this problem by adding a factor 0 < α ≤ 1 to the regularization term, so the new loss becomes
[Equation]
In our experiments, we found little to no performance degradation compared with the same network without randomness, if we choose a suitable hyper-parameter α , as well as the prior distribution
N ( 0 , s 20 I ) .
The overall training algorithm is shown in Alg.
To sum up, our Adv-BNN method trains an arbitrary Bayesian neural network with the min-max robust optimization, which is similar to Madry et al.
As we mentioned earlier, even though our model contains noise and eventually the gradient information is also noisy, by doing multiple forward-backward iterations, the noise will be cancelled out due to the law of large numbers.
This is also the suggested way to bypass some stochastic defenses in Athalye et al.
Algorithm 1 Code
1: procedure pgd attack ( x , y , w ) 2: (cid:46) Perform the PGD omitted brevity 3: procedure train ( data , w ) 4:
(cid:46) Input: dataset network weights w 5: data do 6: x adv ← pgd attack ( x , y, w ) (cid:46)
Generate adversarial images 7: w ← µ + exp( s ) (cid:12) (cid:15) , (cid:15) ∼ N ( 0 d , I d × d ) (cid:46)
Sample new model parameters 8: ˆ y ← forward ( w , x adv ) (cid:46)
Forward propagation 9: loss ce ← cross entropy (ˆ y, y ) (cid:46) Cross-entropy loss 10: loss kl ← kl divergence ( w ) (cid:46) KL-divergence following (6) 11:
L ( µ , s ) ← loss ce + αN tr · loss kl (cid:46) Total loss following (13) 12: ∂ L ∂ µ , ∂ L ∂ s ← backward (cid:0) L ( µ , s ) (cid:1) (cid:46)
Backward propagation to get gradients 13: µ , s ← µ − η t ∂ L ∂ µ , s − η t ∂ L ∂ s (cid:46) SGD update, omitting momentum and weight decay 14: return net
Will it be beneﬁcial to have randomness in adversarial training?
After all, both randomized network and adversarial training can be viewed as different ways for controlling local Lipschitz constants of the loss surface around the image manifold, and thus it is non-trivial to see whether combining those two techniques can lead to better robustness.
The connection between randomized network (in particular, RSE ) and local Lipschitz regularization has been derived in Liu et al.
Adversarial training can also be connected to local Lipschitz regularization with the following arguments.
Recall that the loss function given data ( x i , y i ) is denoted as (cid:96) (cid:0) f
( x i ; w ) , y i (cid:1) , and similarly the loss on perturbed data ( x i + ξ , y i ) is (cid:96) (cid:0) f
( x i + ξ ; w ) , y i ) .
Then if we expand the loss to the ﬁrst order ∆ (cid:96) (cid:44) (cid:96) (cid:0) f ( x i + ξ ; w ) , y i (cid:1) − (cid:96) (cid:0)
[Equation]
(14) we can see that the robustness of a deep model is closely related to the gradient of the loss over the input, i.e. ∇ x i (cid:96) (cid:0) f
( x i ) , y i (cid:1) .
If (cid:107)∇ x i (cid:96) (cid:0) f ( x i ) , y i (cid:1) (cid:107) is large, then we can ﬁnd a suitable ξ such that ∆ (cid:96) is large.
Under such condition, the perturbed image x i + ξ is very likely to be an adversarial example.
It turns out that adversarial training (4) directly controls the local Lipschitz value on the training set , this can be seen if we combine (14) with (4)
[Equation]
Moreover, if we ignore the higher order term O ( (cid:107) ξ (cid:107) 2 ) then (15) becomes
[Equation]
In other words, the adversarial training can be simpliﬁed to Lipschitz regularization, and if the model generalizes, the local Lipschitz value will also be small on the test set .
Yet, as (Liu & Hsieh,
2018) indicates, for complex dataset like CIFAR-10, the local Lipschitz is still very large on test set , even though it is controlled on training set .
The drawback of adversarial training motivates us to combine the randomness model with adversarial training, and we observe a signiﬁcant improvement over adversarial training or RSE alone (see the experiment section below).
E XPERIMENTAL R ESULTS
In this section, we test the performance of our robust Bayesian neural networks ( Adv-BNN ) with strong baselines on a wide variety of datasets.
In essence, our method is inspired by adversarial training (Madry et al., 2017) and BNN (Blundell et al., 2015), so these two methods are natural baselines.
If we see a signiﬁcant improvement in adversarial robustness, then it means that randomness and robust optimization have independent contributions to defense.
Additionally, we would like to compare our method with RSE (Liu et al., 2017), another strong defense algorithm relying on randomization.
Lastly, we include the models without any defense as references.
For ease of reproduction, we list the hyper-parameters in the appendix.
Readers can also refer to the source code on github.
It is known that adversarial training becomes increasingly hard for high dimensional data (Schmidt et al., 2018).
In addition to standard low dimensional dataset such as CIFAR-10, we also did experiments on two more challenging datasets: 1) STL-10 (Coates et al., 2011), which has 5,000 training images and 8,000 testing images.
Both of them are 96 × 96 pixels; 2) ImageNet-143, which is a subset of ImageNet (Deng et al., 2009), and widely used in conditional GAN training (Miyato & Koyama, 2018).
The dataset has 18,073 training and 7,105 testing images, and all images are 64 × 64 pixels.
It is a good benchmark because it has much more classes than CIFAR-10, but is still manageable for adversarial training.
4. E VALUATING MODELS UNDER WHITE BOX (cid:96) ∞ -PGD ATTACK
In the ﬁrst experiment
[Figure]
we compare the accuracy under the white box (cid:96) ∞ -PGD attack.
We set the maximum (cid:96) ∞ distortion to γ ∈ [0:0.07:0.005] and report the accuracy on test set.
The results are shown in Fig.
Note that when attacking models with stochastic components, we adjust PGD accordingly as mentioned in Section 2.1.
To demonstrate the relative performance more clearly, we show some numerical results in Tab. 1.
[Figure]
From Fig.
2 and Tab.
1 we can observe that although BNN itself does not increase the robustness of the model, when combined with the adversarial training method
[Figure]
it dramatically increase the testing accuracy for ∼ 10% on a variety of datasets.
Moreover, the overhead of Adv-BNN over adversarial training is small: it will only double the parameter space (for storing mean and variance), and the total training time does not increase much.
Finally, similar to RSE , modifying existing network
[Table]
into is fairly simple, we only need to replace Conv/BatchNorm/Linear layers by their variational version.
Hence we can easily build robust models based on existing ones
4. B LACK BOX TRANSFER ATTACK
Is our Adv-BNN model susceptible to transfer attack?
we answer this question by studying the afﬁnity between models, because if two models are similar (e.g. in loss landscape) then we can easily attack one model using the adversarial examples crafted through the other.
In this section, we measure the adversarial sample transferability between different models namely None (no defense),
BNN , Adv.
Train , RSE and Adv-BNN .
This is done by the method called “transfer attack” (Liu et al., 2016).
Initially it was proposed as a black box attack algorithm: when the attacker has no access to the target model , one can instead train a similar model from scratch (called source model ), and then generate adversarial samples with source model .
As we can imagine, the success rate of transfer attack is directly linked with how similar the source/target models are.
In this experiment, we are interested in the following question: how easily can we transfer the adversarial examples between these ﬁve models?
We study the afﬁnity between those models, where the afﬁnity is deﬁned by
[Equation]
where ρ A (cid:55)→ B measures the success rate using source model A and target model B , Acc[ B ] denotes the accuracy of model B without attack, Acc[ B | A ( or B )] means the accuracy under adversarial samples generated by model A ( or B ) .
Most of the time, it is easier to ﬁnd adversarial examples through the target model itself, so we have Acc[ B | A ] ≥ Acc[ B | B ] and thus 0 ≤ ρ A (cid:55)→ B ≤ 1 .
However, ρ A (cid:55)→ B = ρ B (cid:55)→ A is not necessarily true, so the afﬁnity matrix is not likely to be symmetric.
We illustrate the result in Fig.
We can observe that { None , BNN } are similar models, their afﬁnity is strong ( ρ ≈ 0 . 85 ) for both direction: ρ BNN (cid:55)→
None and ρ None (cid:55)→ BNN .
Likewise, { RSE , Adv-BNN , Adv.
Train } constitute the other group, yet the afﬁnity is not very strong ( ρ ≈ 0 .
5 ∼ 0 . 6 ), meaning these three methods are all robust to the black box attack to some extent.
4. M ISCELLANEOUS EXPERIMENTS
Following experiments are not crucial in showing the success of our method, however, we still include them to help clarifying some doubts of careful readers.
N o n e
R S E
A d v .
T r a i n B
NN
A d v - B NN
Target models
None
RSE
Adv.
Train
BNN
Adv-BNN
S o u r ce m o d e l s 0 .0 .0 .0 .0 .0 .0 .0 .0 .1 .
C o rr e l a t i o n
The ﬁrst question is about sample efﬁciency, recall in prediction stage we sample weights from the approximated posterior and generate the label by
[Equation]
In practice, we do not want to average over lots of forward propagation to control the variance, which will be much slower than other models during the prediction stage.
Here we take ImageNetdata + VGG network as an example, to show that only 10 ∼ 20 forward operations are sufﬁcient for robust and accurate prediction.
Furthermore, the number seems to be independent on the adversarial distortion, as we can see in Fig.
4( left ).
So our algorithm is especially suitable to large scale scenario.
One might also be concerned about whether 20 steps of PGD iterations are sufﬁcient to ﬁnd adversarial examples.
It has been known that for certain adversarial defense method, the effectiveness appears to be worse than claimed (Engstrom et al., 2018), if we increase the PGD-steps from 20 to 100 .
In Fig.
4( right ), we show that even if we increase the number of iteration to 1000 , the accuracy does not change very much.
This means that even the adversary invests more resources to attack our model, its marginal beneﬁt is negligible.
[Figure] [Figure]
C ONCLUSION & D ISCUSSION
To conclude, we ﬁnd that although the Bayesian neural network has no defense functionality, when combined with adversarial training, its robustness against adversarial attack increases signiﬁcantly.
So this method can be regarded as a non-trivial combination of BNN and the adversarial training: robust classiﬁcation relies on the controlled local Lipschitz value, while adversarial training does not generalize this property well enough to the test set; if we train the BNN with adversarial examples, the robustness increases by a large margin.
Admittedly, our method is still far from the ideal case, and it is still an open problem on what the optimal defense solution will be.
A H OW TO ATTACK THE RANDOMIZED NETWORK
We largely follow the guidelines of attacking networks with “obfuscated gradients” in Athalye et al.
Speciﬁcally, we derive the algorithm for white box attack to random networks denoted as f ( w ; (cid:15) ) , where w is the (ﬁxed) network parameters and (cid:15) is the random vector.
Many random neural networks can be reparameterized to this form, where each forward propagation returns different results.
In particular, this framework includes our Adv-BNN model by setting w = ( µ , s ) .
Recall the prediction is made through “majority voting”:
[Equation] [Equation]
So the optimal white-box attack should maximize the loss (19) on the ground truth label y ∗ .
That is,
[Equation]
and then x adv (cid:44) x + ξ ∗ .
To do that we apply SGD optimizer and sampling (cid:15) at each iteration,
[Equation]
[Equation]
one can see the iteration (21) approximately solves (20).
B F ORWARD & B ACKWARD IN R AND L AYER
It is very easy to implement the forward & backward propagation in BNN.
Here we introduce the
RandLayer that can seamlessly integrate into major deep learning frameworks.
We take PyTorch as an example, the code snippet is shown in Alg. 1.
RandLayerFunc (Function): saved tensors grad
[Table] [Table]
if ctx.needs_input_grad[0]: grad_mu = grad_output
+ mu/(sigma_0*sigma_0*N)
if ctx.needs_input_grad[1]: grad_sigma = grad_output*tmp*eps - 1 / N + tmp*tmp/(sigma_0*sigma_0*N) return grad_mu, grad_sigma, grad_eps, grad_sigma_0, grad_N
rand_layer = RandLayerFunc.apply
Based on RandLayer , we can further implement variational Linear layer below in Alg. 2.
The other layers such as Conv/BatchNorm are very similar.
C H YPER - PARAMETERS
We list the key hyper-parameters in Tab. 2, note that we did not tune the hyper-parameters very hard, therefore it is entirely possible to ﬁnd better ones.
Name
Value
Notes k #PGD iterations in attack k (cid:48)
#PGD iterations in adversarial training γ
CIFAR10/STL
[Table]