L 2 -N ONEXPANSIVE N EURAL N ETWORKS
Anonymous authors
Paper under double-blind review
A BSTRACT
This paper proposes a class of well-conditioned neural networks in which a unit amount of change in the inputs causes at most a unit amount of change in the outputs or any of the internal layers.
We develop the known methodology of controlling Lipschitz constants to realize its full potential in maximizing robustness, with a new regularization scheme for linear layers, new ways to adapt nonlinearities and a new loss function.
With MNIST and CIFAR-10 classiﬁers, we demonstrate a number of advantages.
Without needing any adversarial training, the proposed classiﬁers exceed the state of the art in robustness against white-box L 2 -bounded adversarial attacks.
They generalize better than ordinary networks from noisy data with partially random labels.
Their outputs are quantitatively meaningful and indicate levels of conﬁdence and generalization, among other desirable properties.
I NTRODUCTION
Artiﬁcial neural networks are often ill-conditioned systems in that a small change in the inputs can cause signiﬁcant changes in the outputs (Szegedy et al., 2014).
This results in poor robustness and vulnerability under adversarial attacks which has been reported on a variety of networks including image classiﬁcation (Carlini & Wagner, 2017a; Goodfellow et al., 2014), speech recognition (Kreuk et al., 2018;
Alzantot et al., 2018; Carlini & Wagner, 2018), image captioning (Chen et al., 2017) and natural language processing (Gao et al., 2018; Ebrahimi et al., 2017).
These issues bring up both theoretical questions of how neural networks generalize (Kawaguchi et al., 2017;
Xu & Mannor, 2012) and practical concerns of security in applications (Akhtar & Mian, 2018).
A number of remedies have been proposed for these issues and will be discussed in Section 4.
Whitebox defense is particularly difﬁcult and many proposals have failed.
For example, Athalye et al.
(2018) reported that out of eight recent defense works, only Madry et al.
(2017) survived strong attacks.
So far the mainstream and most successful remedy is that of adversarial training (Madry et al., 2017).
However, as will be shown in Tables 1 and 2, the robustness by adversarial training diminishes when a white-box attacker (Carlini & Wagner, 2017a) is allowed to use more iterations.
This paper explores a different approach and demonstrates that a combination of the following three conditions results in enhanced robustness: 1) the Lipschitz constant of a network from inputs to logits is no greater than 1 with respect to the L 2 -norm; 2) the loss function explicitly maximizes conﬁdence gap , which is the difference between the largest and second largest logits of a classiﬁer; 3) the network architecture restricts conﬁdence gaps as little as possible.
We will elaborate.
There are previous works that achieve the ﬁrst condition (Cisse et al., 2017;
Hein & Andriushchenko, 2017) or bound responses to input perturbations by other means (Kolter & Wong, 2017; Raghunathan et al., 2018; Haber & Ruthotto, 2017).
For example, Parseval networks (Cisse et al., 2017) bound the Lipschitz constant by requiring each linear or convolution layer be composed of orthonormal ﬁlters.
However, the reported robustness and guarantees are often under weak attacks or with low noise magnitude, and none of these works has demonstrated results that are comparable to adversarial training.
In contrast, we are able to build MNIST and CIFAR-10 classiﬁers, without needing any adversarial training, that exceed the state of the art (Madry et al., 2017) in robustness against white-box L 2bounded adversarial attacks.
The defense is even stronger if adversarial training is added.
We will refer to these networks as L 2 -nonexpansive neural networks (L2NNNs).
Our advantage comes from a set of new techniques: our weight regularization, which is key in enforcing the ﬁrst condition, allows greater degrees of freedom parameter training scheme a new loss function is specially designed for the second condition; we adapt various layers in new ways for the third condition, for example norm-pooling and two-sided ReLU, which will be presented later.
Let us begin with intuitions behind the second and third conditions.
Consider a multi-class classiﬁer.
Let g ( x ) denote its conﬁdence gap for an input data point x .
If the classiﬁer is a single L2NNN, 1 we have a guarantee that the classiﬁer will not change its answer as long as the input x is modiﬁed by no more than an L 2 -norm of g ( x ) / √ 2 .
Therefore maximizing the average conﬁdence gap directly boosts robustness and this motivates the second condition.
To explain the third condition, let us introduce the notion of preserving distance: the distance between any pair of input vectors with two different labels ought to be preserved as much as possible at the outputs, while we do not care about the distance between a pair with the same label.
Let d ( x 1 , x 2 ) denote the L 2 -distance between the output logit-vectors for two input points x 1 and x 2 that have different labels and that are classiﬁed correctly.
It is straightforward to verify the condition of g ( x 1 )+ g ( x 2 ) ≤ √ 2 · d ( x 1 , x 2 ) .
Therefore a network that maximizes conﬁdence gaps well must be one that preserves distance well.
Ultimately some distances are preserved while others are lost, and ideally the decision of which distance to lose is made by parameter training rather than by artifacts of network architecture.
Hence the third condition involves distance-preserving architecture choices that leave the decision to parameter training as much as possible, and this motivates many of our design decisions such as Sections 2.2 and 2.3.
In practice we employ the strategy of divide and conquer and build each layer as a nonexpansive map with respect to the L 2 -norm.
It is straightforward to see that a feedforward network composed of nonexpansive layers must implement a nonexpansive map overall.
How to adapt subtleties like recursion and splitting-reconvergence is included in the appendix.
Besides being robust against adversarial noises, L2NNNs have other desirable properties.
They generalize better from noisy training labels than ordinary networks: for example, when 75% of MNIST training labels are randomized, an L2NNN still achieves 93.1% accuracy on the test set, in contrast to 75.2% from the best ordinary network.
The problem of exploding gradients, which is common in training ordinary networks, is avoided because the gradient of any output with respect to any internal signal is bounded between -1 and 1.
Unlike ordinary networks, the conﬁdence gap of an L2NNN classiﬁer is a quantitatively meaningful indication of conﬁdence on individual data points, and the average gap is an indication of generalization.
L 2 - NONEXPANSIVE NEURAL NETWORKS
This section describes how to adapt some individual operators in neural networks for L2NNNs.
Discussions on splitting-reconvergence, recursion and normalization are in the appendix.
2. W EIGHTS
This section covers both the matrix-vector multiplication in a fully connected layer and the convolution calculation between input tensor and weight tensor in a convolution layer.
The convolution calculation can be viewed as a set of vector-matrix multiplications: we make shifted copies of the input tensor and shufﬂe the copies into a set of small vectors such that each vector contains input entries in one tile; we reshape the weight tensor into a matrix by ﬂattening all but the dimension of the output ﬁlters; then convolution is equivalent to multiplying each of the said small vectors with the ﬂattened weight matrix.
Therefore, in both cases, a basic operator is y =
W x .
To be a nonexpansive map with respect to the L 2 -norm, a necessary and sufﬁcient condition is
[Equation]
where ρ denotes the spectral radius of a matrix.
The exact condition of (1) is difﬁcult to incorporate into training.
Instead we use an upper bound:
[Equation]
The above is where our linear and convolution layers differ from those in Cisse et al.
(2017): they require WW T to be an identity matrix, and it is straightforward to see that their scheme is only one special case that makes b ( W ) equal to 1.
Instead of forcing ﬁlters to be orthogonal to each other, our bound of b ( W ) provides parameter training with greater degrees of freedom.
One simple way to use (2) is replacing W with W ′ =
W/
p b ( W ) in weight multiplications, and this would enforce that the layer is strictly nonexpansive.
Another method is described in the appendix.
As mentioned, convolution can be viewed as a ﬁrst layer of making copies and a second layer of vector-matrix multiplications.
With the above regularization, the multiplication layer is nonexpansive.
Hence we only need to ensure that the copying layer is nonexpansive.
For ﬁlter size of K 1 by
K 2 and strides of S 1 by S 2 , we simply divide the input tensor by a factor of
[Equation]
2. R E LU AND OTHERS
Let us turn our attention to the third condition from Section 1.
ReLU, tanh and sigmoid are nonexpansive but do not preserve distance well.
This section presents a method that improves ReLU and is generalizable to other nonlinearities.
A different approach to improve sigmoid is in the appendix.
To understand the weakness of ReLU, let us consider two input data points A and B, and suppose that a ReLU in the network receives two different negative values for A and B and outputs zero for both.
Comparing the A-B distance before and after this ReLU layer, there is a distance loss and this particular ReLU contributes to it.
We use two-sided ReLU which is a function from R to R 2 and simply computes ReLU( x ) and ReLU( − x ). Two-sided ReLU has been studied in Shang et al.
(2016) in convolution layers for accuracy improvement.
It is straightforward to verify that two-sided ReLU is nonexpansive with respect to any L p -norm and that it preserves distance in the above scenario.
We will empirically verify its effectiveness in increasing conﬁdence gaps in Section 3.
Two-sided ReLU is a special case of the following general technique.
Let f ( x ) be a nonexpansive and monotonically increasing scalar function, and note that ReLU, tanh and sigmoid all ﬁt these conditions.
We can deﬁne a function from R to R 2 that computes f ( x ) and f ( x ) − x .
Such a new function is nonexpansive with respect to any L p -norm and preserves distance better than f ( x ) alone.
2. P OOLING
The popular max-pooling is nonexpansive, but does not preserve distance as much as possible.
Consider a scenario where the inputs to pooling are activations that represent edge detection, and consider two images A and B such that A contains an edge that passes a particular pooling window while B does not.
Inside this window, A has positive values while B has all zeroes.
For this window, the A-B distance before pooling is the L 2 -norm of A’s values, yet if max-pooling is used, the A-B distance after pooling becomes the largest of A’s values, which can be substantially smaller than the former.
Thus we suffer a loss of distance between A and B while passing this pooling layer.
We replace max-pooling with norm-pooling, which was reported in Boureau et al.
(2010) to occasionally increase accuracy.
Instead of taking the max of values inside a pooling window, we take the
L 2 -norm of them.
It is straightforward to verify that norm-pooling is nonexpansive and would entirely preserve the L 2 -distance between A and B in the hypothetical scenario above.
Other L p -norms can also be used.
We will verify its effectiveness in increasing conﬁdence gaps in Section 3.
If pooling windows overlap, we divide the input tensor by √ K where K is the maximum number of pooling windows in which an entry can appear, similar to convolution layers discussed earlier.
2. L OSS FUNCTION
For a classiﬁer with K labels, we recommend building it as K overlapping L2NNNs, each of which outputs a single logit for one label.
In an architecture with no split layers, this simply implies that these K L2NNNs share all but the last linear layer and that the last linear layer is decomposed into K single-output linear ﬁlters, one in each L2NNN.
For a multi-L2NNN classiﬁer, we have a guarantee that the classiﬁer will not change its answer as long as the input x is modiﬁed by no more than an
L 2 -norm of g ( x ) / 2 , where again g ( x ) denotes the conﬁdence gap.
As mentioned in Section 1, a single-L2NNN classiﬁer has a guarantee of g ( x ) / √ 2 .
Although this seems better on the surface, it is more difﬁcult to achieve large conﬁdence gaps.
We will assume the multi-L2NNN approach.
We use a loss function with three terms, with trade-off hyperparameters γ and ω :
[Equation]
Let y 1 , y 2 , · · · , y K be outputs from the L2NNNs.
The ﬁrst loss term is
[Equation]
where u 1 , u 2 , · · · , u K are trainable parameters.
The second loss term is
[Equation]
where v can be either a trainable parameter or a hyperparameter.
Note that u 1 , u 2 , · · · , u K and v are not part of the classiﬁer and are not used during inference.
The third loss term is
[Equation]
where z is a hyperparameter.
The rationale for the ﬁrst loss term (4) is that it mimics cross-entropy loss of an ordinary network.
If an ordinary network has been converted to L2NNNs by multiplying each layer with a small constant, its original outputs can be recovered by scaling up L2NNN outputs with certain constants, which is enabled by the formula (4).
Hence this loss term is meant to guide the training process to discover any feature that an ordinary network can discover.
The rationale for the second loss term (5) is that it is directly related to the classiﬁcation accuracy.
Multiplying L2NNN outputs uniformly with v does not change the output label and only adapts to the value range of L2NNN outputs and drive towards better nominal accuracy.
The third loss term (6) approximates average conﬁdence gap: the log term is a soft measure of a conﬁdence gap (for a correct prediction), and is asymptotically linear for larger gap values.
The hyperparameter z controls the degree of softness, and has relatively low impact on the magnitude of loss due to the division by z ; if we increase z then (6) asymptotically becomes the average of minus conﬁdence gaps for correct predictions and zeroes for incorrect predictions.
Therefore loss (6) encourages large conﬁdence gaps and yet is smooth and differentiable.
A notable variation of (3) is one that combines with adversarial training.
Our implementation applies the technique of Madry et al.
(2017) on the ﬁrst loss term (4): we use distorted inputs in calculating
L a .
The results are reported in Tables 1 and 2 as Model 4.
Another possibility is to use distorted inputs in calculating L a and L b , while L c should be based on original inputs.
E XPERIMENTS
Experiments are divided into three groups to study different properties of L2NNNs.
Our MNIST and CIFAR-10 classiﬁers are available at http://dropbox.com/sh/evx6gnz9fk91udk/AAB4BoZffl6Y3xKx-QCViE78a
3. R OBUSTNESS
This section evaluates robustness of L2NNN classiﬁers for MNIST and CIFAR-10 and compares against the state of the art Madry et al.
The robustness metric is accuracy under white-box nontargeted L 2 -bounded attacks.
The attack code of Carlini & Wagner (2017a) is used.
We downloaded the classiﬁers 4 of Madry et al.
(2017) and report their robustness against L 2 -bounded attacks in
Tables 1 and 2.
5 Note that their defense diminishes as the attacks are allowed more iterations.
In reading Tables 1 and 2, it is worth remembering that the norm of after-attack accuracy is zero, and for example the 7.6% on MNIST is currently the state of the art.
Figure 1 illustrates one example of this effect: the ﬁrst image is an attack on MNIST Model 2 ( recognized as 5) found after 1K iterations, with noise L 2 -norm of 4.4, while the second picture is one found after 10K iterations, the same 0 recognized as 5, with noise L 2 -norm of 2.1.
We hypothesize that adversarial training alone provides little absolute defense at the noise levels used in the two tables: adversarial examples still exist and are only more difﬁcult to ﬁnd.
The fact that in Table
Model 2 accuracy is lower in the 1000x10 row than the 10K row further supports our hypothesis.
[Table]
Model 1 is an ordinarily network.
2 is the model from et al.
3 is
[Table]
training.
Model 4 is L2NNN with adversarial training
[Table] [Table]
In contrast
[Table]
the defense of the
L2NNN models remain constant when the attacks are allowed more iterations, speciﬁcally MNIST Models beyond 10K iterations and CIFAR10 Models beyond 1000 iterations.
The reason is that L2NNN classiﬁers achieve their defense by creating a conﬁdence gap between the largest logit and the rest
[Table]
and that half of this gap is a lower bound of
L 2 -norm of distortion to the input data in order to change the classiﬁcation.
Hence L2NNN’s defense comes from a minimum-distortion guarantee.
Although adversarial training alone may also increase the minimum distortion limit for misclassiﬁcation, as suggested
[Table]
for a small network, that limit likely does not reach the levels used in Tables 1 and 2 and hence the defense depends on how likely the attacker can reach a lower-distortion misclassiﬁcation.
Consequently when the attacks are allowed to make more attempts the defense with guarantee stands while the other diminishes.
For both MNIST and CIFAR-10, adding adversarial training boosts the robustness of Model 4.
We hypothesize that adversarial training lowers local Lipschitz constants in certain parts of the input space, speciﬁcally around the training images, and therefore makes local robustness guarantees larger (Hein & Andriushchenko, 2017).
To test the effects of various components of our method, we build models for each of which we disable a different technique during training.
The results are reported in Table 3.
To put the conﬁdence gap values in context, our MNIST Model 3 has an average gap of 2.8.
The ﬁrst one is without weight regularization of Section 2.
and it becomes an ordinary network which has little defense against adversarial attacks; its large average conﬁdence gap is meaningless.
For the second one we remove the third loss term (6) and for the third one we replace norm-pooling with regular max-pooling, both resulting in smaller average conﬁdence gap and less defense against attacks.
For the fourth one, we replace two-sided ReLU with regular ReLU, and this leads to degradation in nominal accuracy, average conﬁdence gap and robustness.
Parseval networks Cisse et al.
(2017) can be viewed as models without L c term, norm-pooling or two-sided ReLU, and with a more restrictive scheme for weight matrix regularization.
Model 3 in Table 1 and the second row of Table 3 are two points along a trade-off curve that are controllable by varying hyperparameter ω in loss function (3).
Two other trade-off points have nominal accuracy and under-attack accuracy of (98.8%,19.1%) and (98.4%,22.6%) respectively.
[Table]
Although we primarily focus on defending against
L 2 -bounded adversarial attacks in this work, we achieve some level of robustness against
L ∞ -bounded attacks as a by-product.
Tableshows our results, again measured with the attack code of Carlini & Wagner (2017a).
The ǫ values match those used in Raghunathan et al.
Kolter & Wong (2017);
Madry et al.
Our MNIST L ∞ results are on par with
Raghunathan et al.
; Kolter & Wong (2017) but not as good as Madry et al.
Our
CIFAR-10 Model 4 is on par with Madry et al.
(2017) for L ∞ defense.
3. M EANINGFUL OUTPUTS
This section discusses how to understand and utilize L2NNNs’ output values.
We observe strong correlation between the conﬁdence gap of L2NNN and the magnitude of distortion needed to force it to misclassify, and images are included in appendix.
In the next experiment, we sort test data by the conﬁdence gap of a classiﬁer on each image.
Then we divide the sorted data into 10 bins and report accuracy separately on each bin in Figure 2.
We repeat this experiment for Model 2 (Madry et al., 2017) and our Model 3 of Tables 1 and 2.
Note that the L2NNN model shows better correlation between conﬁdence and robustness: for MNIST our ﬁrst bin is 95% robust and second bin is 67% robust.
This indicates that the L2NNN outputs are much more quantitatively meaningful than those of ordinary neural networks.
It is an important property that an L2NNN has an easily accessible measurement on how robust its decisions are.
Since robustness is easily measurable, it can be optimized directly, and we believe that this is the primary reason that we can demonstrate the robustness results of Tables 1 and 2.
This can also be valuable in real-life applications where we need to quantify how reliable a decision is.
One of the other practical implications of this property is that we can form hybrid models which use L2NNN outputs when the conﬁdence is high and a different model when the conﬁdence of the L2NNN is low.
This creates another dimension of trade-off between nominal accuracy and robustness that one can take advantage of in an application.
We built such a hybrid model for
MNIST with the switch threshold of 1.0 and achieved nominal accuracy of 99.3%, where only 6.9% of images were delegated to the alternative classiﬁer.
We built such a hybrid model for CIFARwith the switch threshold of 0.1 and achieved nominal accuracy of 89.4%, where 25% of images were delegated.
To put these threshold values in context, MNIST Model 3 has an average gap of 2.8 and CIFAR-10 Model 3 has an average gap of 0.34.
In other words, if for a data point the L2NNN conﬁdence gap is substantially below average, the classiﬁcation is delegated to the alternative classiﬁer, and this way we can recover nominal accuracy at a moderate cost of robustness.
3. G ENERALIZATION VERSUS MEMORIZATION
This section studies L2NNN’s generalization through a noisy-data experiment where we randomize some or all MNIST training labels.
The setup is similar to Zhang et al.
[Table]
except that we added three scenarios where 25%, 50% and 75% of training labels are scrambled.
[Table]
Table 5 shows the comparison between L2NNNs and ordinary networks.
Dropout rate and weightdecay weight are tuned for each WD/DR run, and each WD+DR+ES run uses the combined hyperparameters from its row.
In early-stopping runs, 5000 training images are withheld as validation set and training stops when loss on validation set stops decreasing.
The L2NNNs do not use weight decay, dropout or early stopping.
L2NNNs achieve the best accuracy in all three partially-scrambled scenarios, and it is remarkable that an L2NNN can deliver 93.1% accuracy on test set when three quarters of training labels are random.
More detailed data and discussions are in the appendix.
[Table] [Table]
[Table] [Table]
To illustrate why L2NNNs generalize better than ordinary networks from noisy data
[Table]
we show in Table 6 trade-off points between accuracy and conﬁdence gap on the 50%-scrambled training set.
These trade-off points are achieved by changing hyperparameters ω in (3) and v in (5).
In a noisy training set, there exist data points that are close to each other yet have different labels.
For a pair of such points, if an L2NNN is to ﬁt both labels, the two conﬁdence gaps must be small.
Therefore, in order to achieve large average conﬁdence gap, an L2NNN must misclassify some of the training data.
In Table 6, as we adjust the loss function to favor larger average gap, the
L2NNNs are forced to make more and more mistakes on the training set.
The results suggest that loss is minimized when an L2NNN misclassiﬁes some of the scrambled labels while ﬁtting the 50% original labels with large gaps, and parameter training discovers this trade-off automatically.
Hence we see in Table 6 increasing accuracies and gaps on the test set.
The above is a trade-off between memorization (training-set accuracy) and generalization (training-set average gap), and we hypothesize that L2NNN’s trade-off between nominal accuracy and robustness, reported in Section 3.1, is due to the same mechanism.
To be fair, dropout and early stopping are also able to sacriﬁce accuracy on a noisy training set, however they do so through different mechanisms that tend to be brittle, and Table 5 suggests that L2NNN’s mechanism is superior.
More discussions and the trade-off tables for 25% and 75% scenarios are in the appendix.
Another interesting observation is that the average conﬁdence gap dramatically shrinks in the last row of Table 5 where the training is pure memorization.
This is not surprising again due to training data points that are close to each other yet have different labels.
The practical implication is that after an L2NNN model is trained, one can simply measure its average conﬁdence gap to know whether and how much it has learned to generalize rather than to memorize the training data.
R ELATED WORK
Adversarial defense is a well-known difﬁcult problem (Gilmer et al., 2018; Szegedy et al., 2014;
Carlini & Wagner, 2017a; Goodfellow et al., 2014; Athalye et al., 2018).
There are many avenues to defense (Carlini & Wagner, 2017b;
Meng & Chen, 2017), and here we will focus on defense works that fortify a neural network itself instead of introducing additional components.
The mainstream approach has been adversarial training, where examples of successful attacks on a classiﬁer itself are used in training (Tram`er et al., 2017; Zantedeschi et al., 2017).
The work of
Madry et al.
(2017) has the best results to date and effectively ﬂattens gradients around training data points, and, prior to our work, it is the only work that achieves sizable white-box defense.
It has been reported in Carlini et al.
(2017) that, for a small network, adversarial training indeed increases the average minimum L 1 -norm and L ∞ -norm of noise needed to change its classiﬁcation.
However, in view of results of Tables 1 and 2, adversarial-training results may be susceptible to strong attacks.
The works of Drucker & Le Cun (1992); Ross & Doshi-Velez (2017) are similar to adversarial training in aiming to ﬂatten gradients around training data set but use different mechanisms.
While the above approaches fortify a network around training data points, others aim to bound a network’s responses to input perturbations over the entire input space.
For example, Haber & Ruthotto (2017) models ResNet as an ordinary differential equation and derive stability conditions.
Other examples include Kolter & Wong (2017);
Raghunathan et al.
; Wong et al.
(2018) which achieved provable guarantees against L ∞ -bounded attacks.
However there exist scalability issues with respect to network depth, and the reported results so far are against relatively weak attacks or low noise magnitude.
As shown in Table 4, we can match their measured L ∞ -bounded defense.
Controlling Lipschitz constants also regularizes a network over the entire input space.
Szegedy et al.
(2014) is the seminal work that brings attention to this topic.
Bartlett et al.
(2017) proposes the notion of spectrally-normalized margins as an indicator of generalization, which are strongly related to our conﬁdence gap.
Pascanu et al.
(2013) studies the role of the spectral radius of weight matrices in the vanishing and the exploding gradient problems.
Yoshida & Miyato (2017) proposes a method to regularize the spectral radius of weight matrices and shows its effect in reducing generalization gap.
The work on Parseval networks (Cisse et al., 2017) shows that it is possible to control Lipschitz constants of neural networks through regularization.
The core of their work is to constrain linear and convolution layer weights to be composed of Parseval tight frames, i.e., orthonormal ﬁlters, and thereby force the Lipschitz constant of these layers to be 1; they also propose to restrict aggregation operations.
The reported robustness results of Cisse et al.
(2017), however, are much weaker than those by adversarial training in Madry et al.
We differ from Parseval networks in a number of ways.
Our linear and convolution layers do not require ﬁlters to be orthogonal to each other and subsume Parseval layers as a special case, and therefore provide more freedom to parameter training.
We use non-standard techniques, e.g. two-sided ReLU, to modify various network components to maximize conﬁdence gaps while keeping the network nonexpansive, and we propose a new loss function for the same purpose.
We are unable to obtain Parseval networks for a direct comparison, however it is possible to get a rough idea of what the comparison might be by looking at Tablewhich shows the impacts of those new techniques.
The work of Hein & Andriushchenko (2017) makes an important point regarding guarantees provided by local Lipschitz constants, which helps explain many observations in our results, including why adversarial training on L2NNNs leads to lasting robustness gains.
The regularization proposed by Hein & Andriushchenko (2017) however is less practical and again introduces reliance on the coverage of training data points.
C ONCLUSIONS AND FUTURE WORK
In this work we have presented L 2 -nonexpansive neural networks which are well-conditioned systems by construction.
Practical techniques are developed for building these networks.
Their properties are studied through experiments and beneﬁts demonstrated, including that our MNIST and
CIFAR-10 classiﬁers exceed the state of the art in robustness against white-box adversarial attacks, that they are robust against partially random training labels, and that they output conﬁdence gaps which are strongly correlated with robustness and generalization.
There are a number of future directions, for example, other applications of L2NNN, L2NNN-friendly neural network architectures, and the relation between L2NNNs and interpretability.
A L 2 - NONEXPANSIVE NETWORK COMPONENTS A. A DDITIONAL METHODS FOR WEIGHT REGULARIZATION
There are numerous ways to utilize the bound of (2).
The main text describes a simple method of using W ′ =
W/
p b ( W ) to enforce strict nonexpansiveness.
The following is an alternative.
Approximate nonexpansiveness can be achieved by adding a penalty to the loss function whenever b ( W ) exceeds 1, for example:
[Equation]
[Equation]
The sum of (7) losses over all layers becomes a fourth term in the loss function (3), multiplied with one additional hyperparameter.
This would lead to an approximate L2NNN with trade-offs between how much its layers violate (1) with surrogate (2) versus other objectives in the loss function.
In practice, we have found that it is beneﬁcial to begin neural network training with the regularization scheme of (7), which allows larger learning rates, and switch to the ﬁrst scheme of using W ′ , which avoids artifacts of an extra hyperparameter, when close to convergence.
Of course if the goal is building approximate L2NNNs one can use (7) all the way.
A. S IGMOID AND OTHERS
Sigmoid is nonexpansive as is, but does not preserve distance as much as possible.
A better way is to replace sigmoid with the following operator
[Equation]
where t > 0 is a trainable parameter and each neuron has its own t .
In general, the requirement for any scalar nonlinearity is that its derivative is bounded between -1 and 1.
If a nonlinearity violates this condition, a shrinking multiplier can be applied.
If the actual range of derivative is narrower, as in the case of sigmoid, an enlarging multiplier can be applied to preserve distance.
For further improvement, (8) can be combined with the general form of the two-sided ReLU of
Section 2.2.
Then the new nonlinearity is a function from R to R 2 that computes s ( x ) and s ( x ) − x .
A. S PLITTING AND RECONVERGENCE
There are different kinds of splitting in neural networks.
Some splitting is not followed by reconvergence.
For example, a classiﬁer may have common layers followed by split layers for each label, and such an architecture can be viewed as multiple L2NNNs that overlap at the common layers and each contain one stack of split layers.
In such cases, no modiﬁcation is needed because there is no splitting within each individual L2NNN.
Some splitting, however, is followed by reconvergence.
In fact, convolution and pooling layers discussed earlier can be viewed as splitting, and reconvergence happens at the next layer.
Another common example is skip-level connections such as in ResNet.
Such splitting should be viewed as making two copies of a certain vector.
Let the before-split vector be x 0 , and we make two copies as
[Equation]
where t ∈ [0 , 1] is a trainable parameter.
In the case of ResNet, the reconvergence is an add operator, which should be treated as vectormatrix multiplication as in Section 2.1, but with much simpliﬁed forms.
Let x 1 be the skip-level connections and f ( x 2 ) be the channels of convolution outputs to be added with x 1 , we perform the addition as
[Equation]
where t ∈ [0 , 1] is a trainable parameter and could be a common parameter with (9).
ResNet-like reconvergence is referred to as aggregation layers in Cisse et al.
(2017) and a different formula was used:
[Equation]
11) where α ∈ [0 , 1] is a trainable parameter.
Because splitting is not modiﬁed in Cisse et al.
(2017), their scheme may seem approximately equivalent to ours if a common t parameter is used for (9) and (10).
However, there is a substantial difference: in many ResNet blocks, f ( x 2 ) is a subset of rather than all of the output channels of convolution layers, and our scheme does not apply the shrinking factor of √ 1 − t 2 on channels that are not part of f ( x 2 ) and therefore better preserve distances.
In contrast, because splitting is not modiﬁed, at reconvergence the scheme of Cisse et al.
(2017) must apply the shrinking factor of 1 − α on all outputs of convolution layers, regardless of whether a channel is part of the aggregation or not.
To state the difference in more general terms, our scheme enables splitting and reconvergence at arbitrary levels of granularity and multiplies shrinking factors to only the necessary components.
We can also have a different t per channel or even per entry.
To be fair, the scheme of Cisse et al.
(2017) has an advantage of being nonexpansive with respect to any L p -norm.
However, for L 2 -norm, it is inferior to ours in preserving distances and maximizing conﬁdence gaps.
A. R ECURSION
There are multiple ways to interpret recurrent neural networks (RNN) as L2NNNs.
One way is to view an unrolled RNN as multiple overlapping L2NNNs where each L2NNN generates the output at one time step.
Under this interpretation, nothing special is needed and recurrent inputs to a neuron are simply treated as ordinary inputs.
Another way to interpret an RNN is to view unrolled RNN as a single L2NNN that generates outputs at all time steps.
Under this interpretation, recurrent connections are treated as splitting at their sources and should be handled as in (9).
A. N ORMALIZATION
Normalization operations are limited in an L2NNN.
Subtracting mean is allowed, and subtract-mean operation can be performed on arbitrary subsets of any layer.
Subtracting batch mean is also allowed because it can be viewed as subtracting a bias parameter.
However, scaling, e.g., division by standard deviation or batch standard deviation is only allowed if the multiplying factors are no greater than 1.
B MNIST IMAGES
Gap 5.
Mstk
Dist 4.
Let us begin by showing MNIST images with the largest conﬁdence gaps in Figure 3 and those with the smallest conﬁdence gaps in Figure 4.
They include images before and after attacks as well as Model 3’s conﬁdence gap, the misclassiﬁed label and L 2 -norm of the added noise.
The images with large conﬁdence gaps seem to be ones that are most different from other digits, while some of the images with small conﬁdence gaps are genuinely ambiguous.
It’s worth noting the strong correlation between the conﬁdence gap of L2NNN and the magnitude of distortion needed to force
Gap 0.
Mstk
Dist 0.
it to misclassify.
Also note that our guarantee states that the minimum L 2 -norm of noise is half of the conﬁdence gap, but in reality the needed noise is much stronger than the guarantee.
The reason is that the true local guarantee is in fact larger due to local Lipschitz constants, as pointed out by
Hein & Andriushchenko (2017).
Figure 5 shows additional details regarding the example in Figure 1.
The ﬁrst image is the original image of a zero.
The second image is an attack on Model 2 (Madry et al., 2017) found after 1K iterations, with noise L 2 -norm of 4.4.
The third is one found after 10K iterations for Model 2, with noise L 2 -norm of 2.1.
The last image is the best attack on our Model 3 found after one million iterations, with noise L 2 -norm of 3.5.
These illustrates the trend shown in Table 1 that the defense by adversarial training diminishes as the attacks are allowed more iterations, while L2NNNs withstand strong attacks and it requires more noise to fool an L2NNN.
It’s worth noting that the slow degradation of Model 2’s accuracy is an artifact of the attacker (Carlini & Wagner, 2017a): when gradients are near zero in some parts of the input space, which is true for MNIST Model 2 due to adversarial training, it takes more iterations to make progress.
It is conceivable that, with a more advanced attacker, Model 2 could drop quickly to 7.6%.
What truly matter are the robust accuracies where we advance the state of the art from 7.6% to 24.4%.
C D ETAILS OF SCRAMBLED - LABEL EXPERIMENTS
For ordinary networks in Table 5, we use two network architectures.
The ﬁrst has 4 layers and is the architecture used in Madry et al.
The second has 22 layers and is the architecture of Models 3 and 4 in Table 1, which includes norm-pooling and two-sided ReLU.
Results of ordinary networks using these two architectures are in Tables 7 and 8 respectively.
The ordinary-network section of
Table 5 is entry-wise max of Tables 7 and 8.
In Tables 7 and 8, dropout rate and weight-decay weight are tuned for each WD/DR run, and each
WD+DR+ES run uses the combined hyperparameters from its row.
In early-stopping runs,training images are withheld as validation set and training stops when loss on validation set stops decreasing.
Each ES or WD+DR+ES entry is an average over ten runs to account for randomness of the validation set.
The L2NNNs do not use weight decay, dropout or early stopping.
Table 9 shows L2NNN trade-off points between accuracy and conﬁdence gap on the 25%-scrambled training set.
Table 10 shows L2NNN trade-off points between accuracy and conﬁdence gap on the 75%-scrambled training set.
Like Table 6, they demonstrate the trade-off mechanism between memorization (training-set accuracy) and generalization (training-set average gap).
[Table] [Table]
To be fair
[Table]
dropout and early stopping are also able to sacriﬁce accuracy on a noisy training set.
For example, the DR run in the 50%-scrambled row in Table 7 has 67.5% accuracy on the training set and 72.6% on the test set.
However, the underlying mechanisms are very different from that of L2NNN.
Dropout (Srivastava et al., 2014) has an effect of data augmentation, and, with a noisy training set, dropout can create a situation where the effective data complexity exceeds the network capacity.
Therefore, the parameter training is stalled at a lowered accuracy on the training set, and we get better performance if the model tends to ﬁt more of original labels and less of the scrambled labels.
The mechanism of early stopping is straightforward and simply stops the training when it is mostly memorizing scrambled labels.
We get better performance from early stopping if the parameter training tends to ﬁt the original labels early.
These mechanisms from dropout and early stopping are both brittle and may not allow parameter training enough opportunity to learn from the useful data points with original labels.
The comparison in Table 5 suggests that they are inferior to
L2NNN’s trade-off mechanism as discussed in Section 3.3 and illustrated in Tables 6, 9 and 10.
The
L2NNNs in this paper do not use weight decay, dropout or early stopping, however it is conceivable that dropout may be complementary to L2NNNs. D P ROOFS Lemma 1.
Let g ( x ) denote a single-L2NNN classiﬁer’s conﬁdence gap for an input data point x .
The classiﬁer will not change its answer as long as the input x is modiﬁed by no more than an
L 2 -norm of g ( x ) / √ 2 . Proof. Let y ( x ) = [ y 1 ( x ) , y 2 ( x ) , · · · , y K ( x )] denote logit vector of a single-L2NNN classiﬁer for an input data point x .
Let x 1 and x 2 be two input vectors such that the classiﬁer outputs different labels i and j .
By deﬁnitions, we have the following inequalities:
[Equation]
[Equation]
[Table]
[Table]
Because the classiﬁer is a single L2NNN
[Table]
it must be true that:
[Equation]
Lemma 2.
Let g ( x ) denote a classiﬁer’s conﬁdence gap for an input data point x .
Let d ( x 1 , x 2 ) denote the L 2 -distance between the output logit-vectors for two input points x 1 and x 2 that have different labels and that are classiﬁed correctly.
Then this condition holds: g ( x 1 ) + g ( x 2 ) ≤ √ 2 · d ( x 1 , x 2 ) .
Proof.
Let y ( x ) =
[ y 1 ( x ) , y 2 ( x ) , · · · , y K ( x )] denote logit vector of a classiﬁer for an input data point x .
Let i and j be the labels for x 1 and x 2 .
By deﬁnitions, we have the following inequalities:
[Equation]
Therefore,
[Equation]
Lemma 3.
For any a ≥ 0 , b ≥ 0 , p ≥ 1 , the following inequality holds: a p + b p ≤ ( a + b ) p .
Proof.
If a and b are both zero, the inequality holds.
If at least one of a and b is nonzero:
[Equation]
Lemma 4.
Let f ( x ) be a nonexpansive and monotonically increasing scalar function.
Deﬁne a function from R to R 2 : h ( x ) =
[ f ( x ) , f ( x ) − x ] .
Then h ( x ) is nonexpansive with respect to any
L p -norm.
Proof.
For any x 1 > x 2 , by deﬁnition we have the following inequalities:
[Equation]
For any p ≥ 1 , invoking Lemma 3 with a = f ( x 1 ) − f ( x 2 ) and b = x 1 − x 2 − f ( x 1 ) + f ( x 2 ) , we have:
[Equation]
Lemma 5.
Norm-pooling within each pooling window is a nonexpansive map with respect to L 2norm.
Proof.
Let x 1 and x 2 be two vectors with the size of a pooling window.
By triangle inequality, we have
[Equation]
Therefore,
[Equation]
Therefore,
[Equation]
Lemma 6.
Let g ( x ) denote a multi-L2NNN classiﬁer’s conﬁdence gap for an input data point x .
The classiﬁer will not change its answer as long as the input x is modiﬁed by no more than an
L 2 -norm of g ( x ) / 2 .
Proof.
Let y ( x ) =
[ y 1 ( x ) , y 2 ( x ) , · · · , y K ( x )] denote logit vector of a multi-L2NNN classiﬁer for an input data point x .
Let x 1 and x 2 be two input vectors such that the classiﬁer outputs different labels i and j .
By deﬁnitions, we have the following inequalities:
[Equation]
For a multi-L2NNN classiﬁer, each logit is a nonexpansive function of the input, and it must be true that:
[Equation]
Therefore,
[Equation]