L-INFINITY DISTANCE NETS
Year: 2022

Abstract:
Recently, Zhang et al. (2021) developed a new neural network architecture based on `∞-distance functions, which naturally possesses certified `∞ robustness by its construction. Despite rigorous theoretical guarantees, the model so far can only achieve comparable performance to conventional networks. In this paper, we make the following two contributions: (i) We demonstrate that `∞-distance nets enjoy a fundamental advantage in certified robustness over conventional networks (under typical certification approaches); (ii) With an improved training process we are able to significantly boost the certified accuracy of `∞-distance nets. Our training approach largely alleviates the optimization problem that arose in the previous training scheme, in particular, the unexpected large Lipschitz constant due to the use of a crucial trick called `p-relaxation. The core of our training approach is a novel objective function that combines scaled cross-entropy loss and clipped hinge loss with a decaying mixing coefficient. Experiments show that using the proposed training strategy, the certified accuracy of `∞-distance net can be dramatically improved from 33.30% to 40.06% on CIFAR-10 ( = 8/255), meanwhile outperforming other approaches in this area by a large margin. Our results clearly demonstrate the effectiveness and potential of `∞-distance net for certified robustness. Codes are available at https://github.com/zbh2047/L inf-dist-net-v2.

heading: 1 INTRODUCTION
text: Modern neural networks, while achieving high accuracy on various tasks, are found to be vulnerable to small, adversarially-chosen perturbations of the inputs (Szegedy et al., 2013; Biggio et al., 2013). Given an image x correctly classified by a neural network, there often exists a small adversarial perturbation δ, such that the perturbed image x+ δ looks indistinguishable to x, but fools the network to predict an incorrect class with high confidence. Such vulnerability creates security concerns in many real-world applications.
A large body of works has been developed to obtain robust classifiers. One line of works proposed heuristic approaches that are empirically robust to particular attack methods, among which adversarial training is the most successful approach (Goodfellow et al., 2014; Madry et al., 2017; Zhang et al., 2019a). However, a variety of these heuristics have been subsequently broken by stronger and adaptive attacks (Carlini & Wagner, 2017; Athalye et al., 2018; Uesato et al., 2018; Tramer et al., 2020; Croce & Hein, 2020), and there are no formal guarantees whether the resulting model is truly robust. This motivates another line of works that seeks certifiably robust classifiers whose prediction is guaranteed to remain the same under all allowed perturbations. Representatives of this field use convex relaxation (Wong & Kolter, 2018; Mirman et al., 2018; Gowal et al., 2018; Zhang et al., 2020b) or randomized smoothing (Cohen et al., 2019; Salman et al., 2019a; Zhai et al., 2020; Yang et al., 2020a). However, these approaches typically suffer from high computational cost, yet still cannot achieve satisfactory results for commonly used `∞-norm perturbation scenario.
Recently, Zhang et al. (2021) proposed a fundamentally different approach by designing a new network architecture called `∞-distance net, a name coming from its construction that the basic neuron is defined as the `∞-distance function. Using the fact that any `∞-distance net is inherently a 1- Lipschitz mapping, one can easily check whether the prediction is certifiably robust for a given data
point according to the output margin. The whole procedure only requires a forward pass without any additional computation. The authors further showed that the model family has strong expressive power, e.g., a large enough `∞-distance net can approximate any 1-Lipschitz function on a bounded domain. Unfortunately, however, the empirical model performance did not well reflect the theoretical advantages. As shown in Zhang et al. (2021), it is necessary to use a conventional multi-layer perception (MLP)1 on top of an `∞-distance net backbone to achieve better performance compared to the baseline methods. It makes both the training and the certification procedure complicated. More importantly, it calls into question whether the `∞-distance net is really a better model configuration than conventional architectures in the regime of certified robustness.
In this paper, we give an affirmative answer by showing that `∞-distance net itself suffices for good performance and can be well learned using an improved training strategy. We first mathematically prove that under mild assumptions of the dataset, there exists an `∞-distance net with reasonable size by construction that achieves perfect certified robustness. This result indicates the strong expressive power of `∞-distance nets in robustness certification, and shows a fundamental advantage over conventional networks with typical certification approaches (Mirman et al., 2021). However, it seems to contradict the previous empirical observations, suggesting that the model may fail to find an optimal solution and further motivating us to revisit the optimization process designed in Zhang et al. (2021).
Due to the non-smoothness of the `∞-distance function, Zhang et al. (2021) developed several training tricks to overcome the optimization difficulty. A notable trick is called the `p-relaxation, in which `p-distance neurons are used during optimization to give a smooth approximation of `∞-distance. However, we find that the relaxation on neurons unexpectedly relaxes the Lipschitz constant of the network to an exponentially large value, making the objective function no longer maximize the robust accuracy and leading to sub-optimal solutions.
We develop a novel modification of the objective function to bypass the problem mentioned above. The objective function is a linear combination of a scaled cross-entropy term and a modified clipped hinge term. The cross-entropy loss maximizes the output margin despite the model’s Lipschitzness and makes optimization sufficient at the early training stage when p is small. The clipped hinge loss then focuses on robustness for correctly classified samples at the late training phase when p approaches infinity. The switch from cross-entropy loss to clipped hinge loss is reflected in the mixing coefficient, which decays to zero as p grows to infinity throughout the training procedure.
Despite its simplicity, our experimental results show significant performance gains on various datasets. In particular, an `∞-distance net backbone can achieve 40.06% certified robust accuracy on CIFAR-10 ( = 8/255). This goes far beyond the previous results, which achieved 33.30% certified accuracy on CIFAR-10 using the same architecture (Zhang et al., 2021). Besides, it surpasses the relaxation-based certification approaches by at least 5 points (Shi et al., 2021; Lyu et al., 2021), establishing a new state-of-the-art result.
To summarize, both the theoretical finding and empirical results in this paper demonstrate the merit of `∞-distance net for certified robustness. Considering the simplicity of the architecture and training strategy used in this paper, we believe there are still many potentials for future research of `∞-distance nets, and more generally, the class of Lipschitz architectures.

heading: 2 PRELIMINARY
text: In this section, we briefly introduce the `∞-distance net and its training strategy. An `∞-distance net is constructed using `∞-distance neurons as the basic component. The `∞-distance neuron u takes vector x as the input and calculates the `∞-norm distance between x and parameter w with a bias term b. The neuron can be written as
u(x, {w, b}) = ‖x−w‖∞ + b. (1) Based on the neuron definition, a fully connected `∞-distance net can then be constructed. Formally, an L layer network g takes x(0) = x as the input, and the lth layer x(l) is calculated by
x (l) i = u(x (l−1), {w(l,i), b(l)i }) = ‖x (l−1) −w(l,i)‖∞ + b(l)i , l ∈ [L], i ∈ [nl]. (2)
1Without any confusion, in this paper, a conventional neural network model is referred to as a network composed of linear transformations with non-linear activations.
Here nl is the number of neurons in the lth layer. For K-class classification problems, nL = K. The network outputs g(x) = x(L) as logits and predicts the class arg maxi∈[K][g(x)]i.
An important property of `∞-distance net is its Lipschitz continuity, as is stated below.
Definition 2.1. A mapping f(z) : Rm → Rn is called λ-Lipschitz with respect to `p-norm ‖ · ‖p, if for any z1, z2, the following holds:
‖f(z1)− f(z2)‖p ≤ λ‖z1 − z2‖p. (3)
Proposition 2.2. The mapping of an `∞-distance layer is 1-Lipschitz with respect to `∞-norm. Thus by composition, any `∞-distance net g(·) is 1-Lipschitz with respect to `∞-norm.
`∞-distance nets naturally possess certified robustness using the Lipschitz property. In detail, for any data point x with label y, denote the output margin of network g as
margin(x, y; g) = [g(x)]y −max j 6=y [g(x)]j . (4)
If x is correctly classified by g, then the prediction of a perturbed input x + δ will remain the same as x if ‖δ‖∞ < margin(x, y; g)/2. In other words, we can obtain the certified robustness for a given perturbation level according to I(margin(x, y; g)/2 > ), where I(·) is the indicator function. We call this margin-based certification. Given this certification approach, a corresponding training approach can then be developed, where one simply learns a large margin classifier using standard loss functions, e.g., hinge loss, without using adversarial training. Therefore the whole training procedure is as efficient as training standard networks with no additional cost.
Zhang et al. (2021) further show that `∞-distance nets are Lipschitz-universal approximators. In detail, a large enough `∞-distance net can approximate any 1-Lipschitz function with respect to `∞-norm on a bounded domain arbitrarily well.
Training `∞-distance nets. One major challenge in training `∞-distance net is that the `∞-distance operation is highly non-smooth, and the gradients (i.e. ∇x‖x−w‖∞ and∇w‖x−w‖∞) are sparse. To mitigate the problem, Zhang et al. (2021) used `p-distance neurons instead of `∞-distance ones during training, resulting in approximate and non-sparse gradients. Typically p is set to a small value (e.g., 8) in the beginning and increases throughout training until it reaches a large number (e.g., 1000). The authors also designed several other tricks to further address the optimization difficulty. However, even with the help of tricks, `∞-distance nets only perform competitively to previous works. The authors thus considered using a hybrid model architecture, in which the `∞-distance net serves as a robust feature extractor, and an additional conventional multi-layer perceptron is used as the prediction head. This architecture achieves the best performance, but both the training and the certification approach become complicated again due to the presence of non-Lipschitz MLP layers.

heading: 3 EXPRESSIVE POWER OF `∞-DISTANCE NETS IN ROBUST CLASSIFICATION
text: In this section, we challenge the conclusion of previous work by proving that simple `∞-distance nets (without the top MLP) suffice for achieving perfect certified robustness in classification. Recall that Zhang et al. (2021) already provides a universal approximation theorem, showing the expressive power of `∞-distance nets to represent Lipschitz functions. However, their result focuses on realvalued function approximation and is not directly helpful for certified robustness in classification. One may ask: Does a certifiably robust `∞-distance net exist given a dataset? If so, how large does the network need to be? We will answer these questions and show that one can explicitly construct an `∞-distance net that achieves perfect certified robustness as long as the dataset satisfies the following (weak) condition called r-separation (Yang et al., 2020b).
Definition 3.1. (r-separation) Consider a labeled datasetD = {(xi, yi)}where yi ∈ [K] is the label of xi. We say D is r-separated with respect to `p-norm if for any pair of samples (xi, yi), (xj , yj), as long as yi 6= yj , we have ‖xi − xj‖p > 2r.
It is easy to see that r-separation is a necessary condition for robustness under `p-norm perturbation = r. In fact, the condition holds for all commonly used datasets (e.g., MNIST, CIFAR-10): the value of r in each dataset is much greater than the allowed perturbation level as is demonstrated in Yang et al. (2020b) (see Table 1 above). The authors took a further step and showed there always exists a classifier that achieves perfect robust accuracy if the condition holds. We now prove that even if we restrict the classifier to be the network function class represented by `∞-distance nets, the conclusion is still correct: a simple two-layer `∞-distance net with hidden sizeO(n) can already achieve perfect robustness for r-separated datasets. Theorem 3.2. LetD be a dataset with n elements satisfying the r-separation condition with respect to `∞-norm. Then there exists a two-layer `∞-distance net with hidden size n, such that when using margin-based certification, the certified `∞ robust accuracy is 100% onD under perturbation = r.
Proof sketch. Consider a two layer `∞-distance net g defined in Equation (2). Let its parameters be assigned by
w(1,i) = xi, b (1) i = 0 for i ∈ [n] w (2,j) i = C · I(yi = j), b (2) j = −C for i ∈ [n], j ∈ [K]
where C = 4 maxi∈[n] ‖xi‖∞ is a constant, and I(·) is the indicator function. For the above assignment, it can be proved that the network outputs
[g(x)]j = x (2) j = − min i∈[n],yi=j ‖x− xi‖∞. (5)
From Equation (5) the network g can represent a nearest neighbor classifier, in that it outputs the negative of the nearest neighbor distance between input x and the samples of each class. Therefore, given data x = xi in dataset D, the output margin of g(x) is at least 2r due to the r-separation condition. In other words, g achieves 100% certified robust accuracy on D. Remark 3.3. The above result can be extended to multi-layer networks. In general, we can prove the existence of such networks with L layers and no more than O(n/L + K + d) hidden neurons for each hidden layer where d is the input dimension. See Appendix A for details of the proof.
The significance of Theorem 3.2 can be reflected in the following two aspects. Firstly, our result explicitly shows the strong expressive power of `∞-distance nets in robust classification, which complements the universal approximation theorem in Zhang et al. (2021). Moreover, Theorem 3.2 gives an upper bound of O(n) on the required network size which is close to practical applications. It is much smaller than the size needed for function approximation (O(1/εd) under approximation error ε, proved in Zhang et al. (2021)), which scales exponentially in the input dimension d.
Secondly, our result justifies that for well-designed architectures, using only the global Lipschitz property is sufficient for robustness certification. It contrasts to the prior view that suggests leveraging the local Lipschitz constant is necessary (Huster et al., 2018), which typically needs sophisticated calculations (Wong et al., 2018; Zhang et al., 2018; 2020b). More importantly, as a comparison, Mirman et al. (2021) very recently proved that for any conventional network, the commonlyused interval bound propagation (IBP) (Mirman et al., 2018; Gowal et al., 2018) intrinsically cannot achieve perfect certified robustness on a simple r-separation dataset containing only three data points (under = r). In other words, `∞-distance nets certified using the global Lipschitz property have a fundamental advantage over conventional networks certified using interval bound propagation.

heading: 4 INVESTIGATING THE TRAINING OF `∞-DISTANCE NETS
text: Since robust `∞-distance nets exist in principle, the remaining thing is understanding why the current training strategy cannot find a robust solution. In this section, we first provide evidence that the training method in Zhang et al. (2021) is indeed problematic and cannot achieve good certified robustness, then provide a novel way to address the issue.

heading: 4.1 PROBLEMS OF THE CURRENT TRAINING STRATEGY
text: As shown in Section 2, given any perturbation level , the certified accuracy of data point x can be calculated according to I(margin(x, y; g)/2 ≤ ) for 1-Lipschitz functions. Then the hinge loss becomes standard to learn a robust `∞-distance net:
Lhinge(g,D; θ) = E(xi,yi)∈D [max {θ −margin(xi, yi; g), 0}] , (6)
where θ is the hinge threshold which should be larger than 2 . Hinge loss aims at making the output margin for any sample greater than θ, and Lhinge(g,D; θ) = 0 if and only if the network g achieves perfect certified robustness under perturbation = θ/2.
Hinge loss fails to learn robust classifiers. We first start with some empirical observations. Consider a plain `∞-distance net trained on CIFAR-10 dataset using the same approach and hyperparameters provided in Zhang et al. (2021). When the training finishes, we count the percentage of training samples whose margin is greater than θ, i.e., achieving zero loss. We expect the value to be large if the optimization is successful. However, the result surprisingly reveals that only 1.62% of the training samples are classified correctly with a margin greater than θ. Even if we use much longer training epochs (e.g. 4000 epochs on CIFAR-10), the percentage is still below 2.5% (see Figure 1(a)). Thus we conclude that hinge loss fails to optimize well for most of the training samples.
Since the output margins of the vast majority of training samples are less than θ, the loss approximately degenerates to a linear function without the maximum operation:
Lhinge(g,D; θ) ≈ L̃hinge(g,D; θ) = E(xi,yi)∈D [θ −margin(xi, yi; g)] = θ − E(xi,yi)∈D [margin(xi, yi; g)] ,
(7)
where θ becomes irrelevant, and training becomes to optimize the average margin over the dataset regardless of the allowed perturbation which is definitely problematic.
After checking the hyper-parameters used in Zhang et al. (2021), we find that the hinge threshold θ is set to 80/255, which is much larger than the perturbation level = 8/255. This partly explains the above degeneration phenomenon, but it is still unclear why such a large value has to be taken. We then conduct experiments to see the performance with different chosen hinge thresholds θ. The results are illustrated in Figure 1(b). As we can see, a smaller hinge threshold not only reduces certified test accuracy but even makes training worse.
Why does this happen? We find that the reason for the loss degeneration stems from the `prelaxation used in training. While `p-relaxation alleviates the sparse gradient problem, it destroys the Lipschitz property of the `∞-distance neuron, as stated in Proposition 4.1: Proposition 4.1. A layer constructed using `p-distance neurons
up(x, {w, b}) = ‖x−w‖p + b (8) is d1/p Lipschitz with respect to `∞-norm, where d is the dimension of x. Thus by composition, an L layer `p-distance net is dL/p Lipschitz with respect to `∞-norm.
Zhang et al. (2021) uses a small p in the beginning and increases its value gradually during training. From Proposition 4.1, the Lipschitz constant of the smoothed network can be significantly large2 at
2For a 6-layer `p-distance net (p = 8) with hidden size 5120 used in Zhang et al. (2021), Proposition 4.1 approximately gives a Lipschitz constant of 568. We also run experiments to validate such upper bound is relatively tight. See Appendix C for more details.
the early training stage. Note that the robustness certification I(margin(x, y; g)/2 ≤ ) holds for 1-Lipschitz functions. When the Lipschitz constant is large, even if the margin of a data point passes the threshold, the data point can still lie near to classification boundary. This makes the training using hinge loss ineffective at the early stage and converge to a wrong solution far from the real optima. We argue that the early-stage training is important as when p rises to a large value, the optimization becomes intrinsically difficult to push the parameters back to the correct solution due to sparse gradients.
Such argument can be verified from Figure 1(a), in which we plot the percentage of training samples with margins greater than θ throughout a long training process. After p starts to rise, the margin decreases drastically, and the percentage sharply drops and never increases again during the whole `p-relaxation procedure. It is also clear why the value of θ must be chosen to be much larger than 2 . For small θ, the margin optimization becomes insufficient at early training stages when the Lipschitz constant is exponentially large, leading to worse performance even on the training dataset.

heading: 4.2 OUR SOLUTION
text: In the previous section, one can see that the hinge loss and the `p-relaxation are incompatible. As the `p-relaxation is essential to overcome the sparse gradient problem, we focus on developing better loss functions. We show in this section that a simple change of the objective function can address the above problem, leading to non-trivial improvements.
We approach the issue by investigating the commonly used cross-entropy loss. For conventional non-Lipschitz networks, cross-entropy loss aims at increasing the logit of the true class while decreasing the other logits as much as possible, therefore enlarges the output margin without a threshold constraint. This makes the optimization of output margin sufficient, which largely alleviates the problem in Section 4.1 for training `p-distance nets with small p. Such findings thus motivate us to replace hinge loss with cross-entropy. However, on the other hand, cross-entropy loss only coarsely enlarges the margin, rather than exactly optimizing the surrogate of certified accuracy I(margin(x, y; g)/2 ≤ ) that depends on . When the model is almost 1-Lipschitz (i.e. p approaches infinity), hinge loss can still be better than cross-entropy. In other words, cross-entropy loss and hinge loss are complementary.
Based on the above argument, we propose to simply combine cross-entropy loss and hinge loss to obtain the following objective function:
L(g,D; θ) = E(xi,yi)∈D[λ`CE(s · g(xi), yi)︸ ︷︷ ︸ scaled cross-entropy loss + min{`hinge(g(xi)/θ, yi), 1}︸ ︷︷ ︸ clipped hinge loss ] (9)
where `CE(z, y) = log( ∑ i exp(zi))− zy and `hinge(z, y) = max{maxi 6=y zi − zy + 1, 0}. We now make detailed explanations about each term in Equation (9).
Scaled cross-entropy loss `CE(s · g(xi), yi). Cross-entropy loss deals with the optimization issue when p is small. Here a slight difference is the introduced scaling s as is explained below. We know cross-entropy loss is invariant to the shift operation (adding a constant to each output logit) but not scaling (multiplying a constant). For conventional networks, the output logits are produced through the last linear layer, and the scaling factor can be implicitly learned in the parameters of the linear layer to match the cross-entropy loss. However, `∞-distance net is strictly 1-Lipschitz and does not have any scaling operation. We thus introduce a learnable scalar (temperature) s that multiplies the network output g(xi) before taking cross-entropy loss. We simply initialize it to be 1. Note that s does not influence the classification results and can be removed once the training finishes.
Clipped hinge loss min{`hinge(g(xi)/θ, yi), 1}. Clipped hinge loss is designed to achieve robustness when p approaches infinity. Unlike the standard hinge loss, the clipped version plateaus if the output margin is negative (i.e., misclassified). In other words, clipped hinge loss is equivalent to applying hinge loss only on correctly-classified samples. The reason for applying such a clipping is three-fold. (i) Scaled cross-entropy loss already focuses on learning a model with high (clean) accuracy, thus there is no need to optimize on wrongly-classified samples duplicatively using hinge loss. Moreover, cross-entropy is better than hinge loss when used in classification, as the gradient of hinge loss makes optimization harder3. (ii) In the late training phase, the optimization becomes
3The gradient of hinge loss w.r.t. output logits is sparse (only two non-zero elements) and does not make full use of the information provided by the logit.
intrinsically difficult (p approaching infinity). As a consequence, wrongly classified samples may have little chance to be robust. Clipped hinge loss thus ignores these samples and concentrates on easier ones to increase their potential to be robust after training. (iii) The clipped hinge loss is a better surrogate for 0-1 robust error I(margin(x, y; g)/2 ≤ ). Compared with hinge loss, the clipped version is closer to our goal and more likely to achieve better certified accuracy. Finally, due to the presence of cross-entropy loss, we will show in Section 5.3 that the hinge threshold θ can be set to a much smaller value unlike Figure 1(b), which thus avoids the loss degeneration problem.
The mixing coefficient λ. The coefficient λ in loss (9) plays a role in the trade-off between crossentropy and hinge loss. Based on the above motivation, we use a decaying λ that attenuates from λ0 to zero throughout the process of `p-relaxation (λ0 is a hyper-parameter). When p is small at the early training stage, we focus more on cross-entropy loss. After p grows large, λ vanishes, and a surrogate of 0-1 robust error is optimized.
We point out that objective functions similar to (9) also appeared in previous literature. In particular, the TRADES loss (Zhang et al., 2019a) and MMA loss (Ding et al., 2020) are both composed of a mixture of the cross-entropy loss and a form of robust loss. Nevertheless, the motivations of these methods are quite different. For example, TRADES was proposed based on the theoretical results suggesting robustness may be at odds with accuracy (Tsipras et al., 2019), while our training approach is mainly motivated by the optimization issue. Furthermore, the implementations of these methods also vary a lot. We use clipped hinge loss to achieve robustness due to its simplicity, and uses a decaying λ correlate to p in `p-relaxation due to the optimization problem in Section 4.1.

heading: 5 EXPERIMENTS

heading: 5.1 EXPERIMENTAL SETTING
text: In this section, we evaluate the proposed training strategy on benchmark datasets MNIST and CIFAR-10 to show the effectiveness of `∞-distance net.
Model details. We use exactly the same model as Zhang et al. (2021) for a fair comparison. Concretely, we consider the simple fully-connect `∞-distance nets defined in Equation (2). All hidden layers have 5120 neurons. We use a 5-layer network for MNIST and a 6-layer one for CIFAR-10.
Training details. In all experiments, we choose the Adam optimizer with a batch size of 512. The learning rate is set to 0.03 initially and decayed using a simple cosine annealing throughout the whole training process. We use padding and random crop data augmentation for MNIST and CIFAR-10, and also use random horizontal flip for CIFAR-10. The `p-relaxation starts at p = 8 and ends at p = 1000 with p increasing exponentially. The mixing coefficient λ decays exponentially during the `p-relaxation process from λ0 to a vanishing value λend. We do not use further tricks that are used in Zhang et al. (2021), e.g. the `p weight decay or a warmup over perturbation , to keep our training strategy clean and simple. The dataset dependent hyper-parameters, including θ, λ0, λend and the number of epochs T , can be found in Appendix B. All experiments are run for 8 times on a single NVIDIA Tesla-V100 GPU, and the median of the performance number is reported.
Evaluation. We test the robustness of the trained models under -bounded `∞-norm perturbations. Following the common practice (Madry et al., 2017), we mainly use = 0.3 for MNIST dataset and 8/255 for CIFAR-10 dataset. We also provide results under other perturbation magnitudes, e.g. = 0.1 for MNIST and = 2/255, = 16/255 for CIFAR-10. We first evaluate the robust test accuracy under the Projected Gradient Descent (PGD) attack (Madry et al., 2017). The number of iterations of the PGD attack is set to a large number of 100. We then calculate the certified robust accuracy based on the output margin.

heading: 5.2 EXPERIMENTAL RESULTS
text: Results are presented in Table 2. For each method in the table, we report the clean test accuracy without perturbation (denoted as Clean), the robust test accuracy under PGD attack (denoted as PGD), and the certified robust test accuracy (denoted as Certified). We also compare with randomized smoothing (see Appendix D), despite these methods provides probabilistic certified guarantee and usually take thousands of times more time than other approaches for robustness certification.
∗ The IBP results are obtained from Zhang et al. (2020b). † These results are obtained by running the code in the authors’ github. See Appendix B for details. ‡ The number of PGD steps is chosen as 20 in Zhang et al. (2021). § These methods provide probabilistic certified guarantees. ‖ Calculating certified accuracy for these methods takes several days on a single GPU, which is 4 to 6 orders of magnitude slower than other methods.
Comparing with Zhang et al. (2021). It can be seen that for all perturbation levels and datasets, our proposed training strategy improves the performance of `∞-distance nets. In particular, we boost the certified accuracy on CIFAR-10 from 33.30% to 40.06% under = 8/255, and from 19.28% to 29.04% under a larger = 16/255. Note that we use exactly the same architecture as Zhang et al. (2021), and a larger network with better architecture may further improve the results. Another observation from Table 2 is that the improvement of our proposed training strategy gets more prominent with the increase of . This is consistent with our finding in Section 4.1, in that the optimization is particularly insufficient for large using hinge loss, and in this case our proposed objective function can significantly alleviate such problem.
Comparing with other certification methods. For most settings in Table 2, our results establish new state-of-the-arts over previous baselines, despite we use the margin-based certification which is much simpler. The gap is most noticeable for = 8/255 on CIFAR-10, where we surpass recent relaxation-based approaches by more than 5 points (Shi et al., 2021; Lyu et al., 2021). It can also be observed that `∞-distance net is most suitable for the case when `∞ perturbation is relatively large. This is not surprising since Lipschitz property is well exhibited in this case. If is vanishing small, the advantage of the Lipschitz property will not be well-exploited and `∞-distance net will face more optimization and generalization problems compared with conventional networks.

heading: 5.3 INVESTIGATING THE PROPOSED TRAINING STRATEGY
text: We finally demonstrate by experiments that the proposed training strategy indeed addresses the optimization problem in Section 4.1. We first trace the output margin of the training samples throughout training on CIFAR-10 dataset ( = 8/255), and plot the percentage of samples with a margin greater than θ, less than 0, or between 0 and θ, shown in Figure 2(a). In contrast to Figure 1(a), it can be seen that the loss does not degenerate in the whole training process. We then demonstrate in Figure 2(b) that the accuracy curve regarding different choices of hinge threshold θ is well-behaved compared with Figure 1(b). In particular, the best θ that maximizes the certified accuracy on training dataset approaches 2 (while for original hinge loss the value is 6 ). The peak certified accuracy on training dataset also improves by 10 points (see blue lines in the two figures). Such evidence clearly demonstrates the effectiveness of the proposed training strategy.
Sensitivity analysis. We perform sensitivity analysis on CIFAR-10 dataset ( = 8/255) over hyperparameters including the hinge threshold θ and the mixing coefficient λ. Results are shown in Figure 2(b) and 2(c). It can be seen that (i) the certified accuracy is above 39% for a wide range of θ (between 5 and 8 ); (ii) among the 20 hyper-parameter combinations of (λ0, λend), all certified accuracy results surpass 39%, and half of the results can achieve a certified accuracy of more than 39.75%. In summary, the performance is not sensitive to the choice of the hyper-parameters θ and λ. See Appendix F for more details on other hyper-parameters.
Ablation studies. We also conduct ablation experiments for the proposed loss function on CIFAR10 dataset ( = 8/255). Due to the space limit, we put results in Appendix E. In summary, both the cross-entropy loss and clipped hinge loss are crucial to boost the certified accuracy. Using a decaying mixing coefficient λ can further improve the performance and stabilize the training.

heading: 6 RELATED WORK
text: In recent years substantial efforts have been taken to obtain robust classifiers. Existing approaches mainly fall into two categories: adversarial training and certified defenses.
Adversarial training. Adversarial training methods first leverage attack algorithms to generate adversarial examples of the inputs on the fly, then update the model’s parameters using these perturbed inputs together with the original labels (Goodfellow et al., 2014; Kurakin et al., 2016; Madry et al., 2017). In particular, Madry et al. (2017) suggested using Projected Gradient Descent (PGD) as the universal attacker to find a perturbation that maximizes the standard cross-entropy loss, which achieves decent empirical robustness. Some recent works considered other training objectives that combine cross-entropy loss and a carefully designed robust surrogate loss (Zhang et al., 2019a; Ding et al., 2020; Wang et al., 2020), which show similarities to this paper. However, all methods above are evaluated empirically using first-order attacks such as PGD, and there is no formal guarantee whether the learned model is truly robust. This motivates researchers to study a new type of method
called certified defenses, in which the prediction is guaranteed to remain the same under all allowed perturbations, thus provably resists against all potential attacks.
Relaxation-based certified defenses. These methods adopt convex relaxation to calculate a convex region containing all possible network outputs for a given input under perturbation (Wong & Kolter, 2018; Wong et al., 2018; Dvijotham et al., 2018; 2020; Raghunathan et al., 2018a;b; Weng et al., 2018; Singh et al., 2018; Mirman et al., 2018; Gehr et al., 2018; Wang et al., 2018; 2021; Gowal et al., 2018; Zhang et al., 2018; 2020b; Xiao et al., 2019; Croce et al., 2019; Balunovic & Vechev, 2020; Lee et al., 2020; Dathathri et al., 2020; Xu et al., 2020; Lyu et al., 2021; Shi et al., 2021). If all points in this region correspond to the correct prediction, then the network is provably robust. However, the relaxation procedure is usually complicated and computationally expensive. Furthermore, Salman et al. (2019b); Mirman et al. (2021) indicated that there might be an inherent barrier to tight relaxation for a large class of convex relaxation approaches. This is also reflected in experiments, where the trained model often suffers from severe accuracy drop even on training data.
Randomized smoothing for certified robustness. Randomized smoothing provides another way to calculate a probabilistic certification under `2 perturbations (Lecuyer et al., 2019; Li et al., 2019a; Cohen et al., 2019; Salman et al., 2019a; Zhai et al., 2020; Jeong & Shin, 2020; Zhang et al., 2020a). For any classifier, if a Gaussian random noise is added to the input, the resulting “smoothed” classifier then possesses a certified guarantee under `2 perturbations. Randomized smoothing has been scaled up to ImageNet and achieves state-of-the-art certified accuracy for `2 perturbations. However, recent studies imply that it cannot achieve nontrivial certified accuracy for `p perturbations under = Ω(d1/p−1/2) when p > 2 which depends on the input dimension d (Yang et al., 2020a; Blum et al., 2020; Kumar et al., 2020; Wu et al., 2021). Therefore it is not suitable for `∞ perturbation scenario if is not very small.
Lipschitz networks. An even simpler way for certified robustness is to use Lipschitz networks, which directly possess margin-based certification. Earlier works in this area mainly regard the Lipschitz property as a kind of regularization and penalize (or constrain) the Lipschitz constant of a conventional ReLU network based on the spectral norms of its weight matrices (Cisse et al., 2017; Yoshida & Miyato, 2017; Gouk et al., 2018; Tsuzuku et al., 2018; Farnia et al., 2019; Qian & Wegman, 2019; Pauli et al., 2021). However, these methods either can not provide certified guarantees or provide a vanishing small certified radius. Anil et al. (2019) figured out that current Lipschitz networks intrinsically lack expressivity to some simple Lipschitz functions, and designed the first Lipschitz-universal approximator called GroupSort network. Li et al. (2019b); Singla & Feizi (2021) studied Lipschitz networks for convolutional architectures. Leino et al. (2021) achieved the stateof-the-art certified robustness using GroupSort network under `2 perturbations. However, none of these approaches above can provide good certified results for `∞ robustness. The most relevant work to this paper is Zhang et al. (2021), in which the author designed a novel Lipschitz network with respect to `∞-norm. We show such architecture can establish new state-of-the-art results in the `∞ perturbation scenario.

heading: 7 CONCLUSION
text: In this paper, we demonstrate that a simple `∞-distance net suffices for good certified robustness from both theoretical and experimental perspectives. Theoretically, we prove the strong expressive power of `∞-distance nets in robust classification. Combining with Mirman et al. (2021), this result may indicate that `∞-distance nets have inherent advantages over conventional networks for certified robustness. Experimentally, despite simplicity, our approach yields a large gain over previous (possibly more complicated) certification approaches and the trained models establish new state-of-the-art certified robustness.
Despite these promising results, there are still many aspects that remain unexplored. Firstly, in the case of very small setting `∞-distance nets may have a lot of room for improvement. Secondly, it is important to design better architectures suitable for image classification tasks than the simple fully connected network used in this paper. Finally, it might be interesting to design better optimization algorithms for `∞-distance nets to further handle the model’s non-smoothness and gradient sparsity. We hope this work can make promising the study of `∞-distance nets, and more generally, the global Lipschitz architectures for certified robustness.

heading: A PROOF OF THEOREM 3.2 AND BEYOND
text: Theorem A.1. LetD be a dataset with n elements satisfying the r-separation condition with respect to `∞-norm. Then there exists a two-layer `∞-distance net with hidden size n, such that the certified `∞ robust accuracy is 100% on D under perturbation = r.
Proof. Consider a two layer `∞-distance net g defined in Equation (2). Let its parameters be assigned by
w(1,i) = xi, b (1) i = 0 for i ∈ [n] w (2,j) i = C · I(yi = j), b (2) j = −C for i ∈ [n], j ∈ [K]
(10)
where C = 4 maxi∈[n] ‖xi‖∞ is a constant, and I(·) is the indicator function. The chosen of C is large enough so that the following holds:
‖xi − xj‖ ≤ C/2 ∀(xi, yi), (xj , yj) ∈ D (11)
For the above assignment, the first layer simply calculates the `∞-distance between x and each sample in dataset D. We now derive the output of the second layer. We have
[g(x)]j = x (2) j = ‖x (1) −w(2,j)‖∞ + b(2,j)
= b(2,j) + max i∈[n] |x(1)i − w (2,j) i |
= −C + max {
max i∈[n],yi=j |x(1)i − C|, max i∈[n],yi 6=j
|x(1)i | }
= −C + max {
max i∈[n],yi=j |‖x− xi‖∞ − C| , max i∈[n],yi 6=j
‖x− xi‖∞ }
(12)
= −C + max i∈[n],yi=j (C − ‖x− xi‖∞) (13)
= − min i∈[n],yi=j ‖x− xi‖∞. (14)
Here a core step is Equation (13) which follows by using Inequality (11) when the image x is in dataset D. From Equation (14) the network g can represent a nearest neighbor classifier, in that it outputs the negative of the nearest neighbor distance between input x and the samples of each class. Therefore, given data x = xi in datasetD, the output [g(x)]j is either 0 or less than−2r depending on whether j = yi, due to the r-separation condition. Therefore the output margin is at least 2r. In other words, g achieves 100% certified robust accuracy on D.
We now give a general result which shows that any L layer (L ≥ 2) `∞-distance net with hidden size O(n/L + K + d) can achieve perfect certified robustness. In this general setting, the total number of neurons in the network is thus O(n+KL+ dL) which is still close to real practice.
Theorem A.2. LetD be a dataset with n elements satisfying the r-separation condition with respect to `∞-norm. Then there exists an L-layer `∞-distance net with hidden size no more than d nL−1e + K + 2d where d is the input dimension, such that the certified `∞ robust accuracy is 100% on D under perturbation = r.
Proof. The basic idea is to rearrange the computation process of the two-layer network in the above proof by order so as to satisfy the width constraint. To formulate the proof below, we first define some notations. Define K prefix arrays hj(j ∈ [K]) as follows:
hj,k = − min i∈[k],yi=j ‖x− xi‖∞. (15)
Note that we want the network output to be the negative of the nearest neighbor distance of all samples in a class j, i.e. −mini∈[n],yi=j ‖x − xi‖∞, which corresponds to hj,n. For any hidden layer x(l) (l ∈ [L− 1]), we separate it into four sets: I(l) = {x(l)i : i ∈ [d]}, Ĩ(l) = {x (l) i : d < i ≤
2d}, O(l) = {x(l)i : 2d < i ≤ 2d+K} and S(l) containing the rest d nL−1e neurons. We also denote O(L) = {x(L)i : i ∈ [K]} for ease of presentation.
We first make a construction in which the neurons of I(l) in each layer exactly represent the input x, e.g. x(l)i = xi (1 ≤ i ≤ d). This is feasible since an `∞-distance neuron can represent the operation that fetches an element of the neuron input on a bounded domain, e.g. the following operation
u(z, {w, b}) = ‖z −w‖∞ + b = zj ∀z ∈ K (16) if we assign wj = −C, b = −C,wk = 0(k 6= j) where C is larger than twice the diameter of domain K. In this way, all hidden neurons in the network can have access to the network input x. We similarly let the neurons of Ĩ(l) represent the input x again, e.g. x(l)i+d = xi (d < i ≤ 2d).
Next, we aim at designing the following computation pattern for O(l):
O(l) = {h j,dn(l−1)L−1 e : j ∈ K} e.g. x(l)2d+j = hj,dn(l−1)L−1 e. (17)
In this way O(L) = {hj,n : j ∈ [K]}, and the network exactly represents a nearest neighbor classifier which is desired. To represent O(l+1) in (17), we use the following recursive relation
x (l+1) 2d+j = hj,d nlL−1 e = max { h j,dn(l−1)L−1 e
, max dn(l−1)L−1 e<i≤d nl L−1 e,yi=j
−‖x− xi‖∞ } . (18)
Note that h j,dn(l−1)L−1 e
= x (l) 2d+j is already calculated in O(l) in the previous layer. The left thing is to calculate ‖x− xi‖∞ for all i ∈ { dn(l−1)L−1 e+ 1, · · · , d nl L−1e } , which can be done by the neurons of
the set S(l) in the previous layer (which will be proven later). Assume S(l) represents S(l) = { x (l) 2d+K+i : i ∈ [ d nL−1e ]} , x (l) 2d+K+i = ∥∥∥x− xdn(l−1)L−1 e+i∥∥∥∞ , (19) then the neuron x(l+1)2d+j merges the information of neuron x (l) 2d+j and part of neurons x (l) 2d+K+i in S(l) depending on whether yi = j, using the construction similar to (10). In detail,
x (l+1) 2d+j = ‖x (l) −w(l+1,2d+j)‖∞ + b(l+1)2d+j = hj,d nlL−1 e (20)
holds by assigning
w (l+1,2d+j) k = −C · I(k = 2d+ j) for k ∈ [2d+K] w (l+1,2d+j) 2d+K+i = C · I(ydn(l−1)L−1 e+i = j) for i ∈ [ d nL−1e ] b (l+1) 2d+j = −C
where C is a sufficiently large constant.
Now it remains to represent S(l) in (19). We first consider the simplest case when l = 1. In this case we can directly calculate x(1)2d+K+i = ‖x − xi‖∞ by assigning proper weights and zero bias. Now assume l ≥ 2. In this case, we cannot calculate the `∞-distance directly since the previous layer has irrelavant neurons, e.g. the neurons in sets O(l−1) and S(l−1). We want to only use the sets of neurons I(l−1) and Ĩ(l−1) in the previous layer. Suppose the objective is to represent ‖x− xi‖∞ for some i. Note that
‖x− xi‖∞ = max k∈[d] max{xk − [xi]k, [xi]k − xk}.
We assign the parameters of the `∞-distance neuron x (l) j = ‖x(l−1) −w(l,j)‖∞ + b (l) j for some j as follows: w
(l,j) k = [xi]k − C for k ∈ [d] w (l,j) d+k = [xi]k + C for k ∈ [d] w (l,j) 2d+k = 0 for k ∈ [ K + d nL−1e ] b (l) j = −C
where C is a sufficiently large constant. In this way
x (l) j = ‖x (l−1) −w(l,j)‖∞ + b(l)j
= b (l) j + max maxk∈[d] |x(l−1)k − w(l,j)k |,maxk∈[d] |x(l−1)d+k − w(l,j)d+k |, maxk∈[K+d nL−1 e] |x(l−1)2d+k − w(l,j)2d+k| 
= −C + max {
max k∈[d]
(x (l−1) k − [xi]k + C),max k∈[d] (−x(l−1)d+k + [xi]k + C) } = max { max k∈[d] (xk − [xi]k),max k∈[d] (−xk + [xi]k) }
= ‖x− xi‖∞
which is desired. Proof completes.

heading: B ADDITIONAL EXPERIMENTAL DETAILS AND HYPER-PARAMETERS
text: Our experiments are implemented using the Pytorch framework. We run all experiments in this paper using a single NVIDIA Tesla-V100 GPU. The CUDA version is 11.2.
The learnable scalar in Equation (9) is initialized to be one and trained using a smaller learning rate that is one-fifth of the base learning rate. This is mainly to make training stable as suggested in Zhang et al. (2019b) since the scalar scales the whole network output. The final performance is not sensitive to the scalar learning rate as long as it is set to a small value. For random crop data augmentation, we use padding = 1 for MNIST and padding = 3 for CIFAR-10. The model is initialized using identity-map initialization (see Section 5.3 in Zhang et al. (2021)), and mean-shift batch normalization is used for all intermediate layers. The training procedure is as follows:
• In the first e1 epochs, we set p = 8 in `p-relaxation and use λ = λ0 as the mixing coefficient;
• In the next e2 epochs, p exponentially increases from 8 to 1000. Accordingly, λ exponentially decreases from λ0 to a vanishing small value λend;
• In the final e3 epochs, p is set to infinity and λ is set to 0.
All hyper-parameters are provided in Table 3. Most hyper-parameters are directly borrow from Zhang et al. (2021), e.g. hyper-parameters of the optimizer, the batch size, and the value p in `prelaxation. The only searched hyper-parameters are the hinge threshold θ and the mixing coefficient λ0, λend. These hyper-parameters are obtained using a course grid search.
We also run additional experiments using the training strategy in Zhang et al. (2021) for performance comparison when the original paper does not present the corresponding results. This mainly includes the case = 0.1 on MNIST and = 2/255, = 16/255 on CIFAR-10, as shown in Table 2. We use the same hyper-parameters in Zhang et al. (2021), except for the hinge threshold θ where we perform a careful grid search. The choice of θ is listed in Table 4.
Table 4: Best hinge thresholds for different settings using the training strategy in Zhang et al. (2021).
Dataset MNIST CIFAR-10 0.1 0.3 2/255 8/255 16/255
Hinge threshold θ 0.8 0.9 32/255 80/255 128/255
0.0 0.2 0.4 0.6 0.8 1.0 quantile
50
75
100
125
150
175 200 Lip sc hi tz Zhang et al. (2021) This paper
Loss LipschitzAverage Max Zhang et al. (2021) 123.5 168.4
This paper 121.5 183.4
Figure 3: Approximating the Lipschitz constant of `p-distance net when p = 8, trained using different loss functions on CIFAR-10 dataset. The left figure plots the calculated value of (21) over the test set at each quantile. The right table provides the statistical information.
C THE LIPSCHITZ CONSTANT OF `p-DISTANCE NET
We have shown in Section 4.1 that an L layer `p-distance net with d neurons in each hidden layer is dL/p Lipschitz with respect to `∞-norm. The value becomes quite large if p is small. For example, Zhang et al. (2021) uses a 6-layer `p-dist net with d = 5120. This gives a Lipschitz constant of approximate 568 when p = 8 at the beginning of training.
One may ask whether such upper bound of Lipschitz constant (Proposition 4.1) is tight and reflects the true Lipschitz property in practice. To validate the tightness of the bound, we run the following experiments. Consider the `∞-distance net used in Zhang et al. (2021). We train this architecture following the training strategy either in Zhang et al. (2021) or in this paper. After training finishes, we then set p = 8 without changing the model parameters. We approximate the Lipschitz constant of the model using Projected Gradient Descent (PGD), which provides a lower bound estimate. In detail, for each image x in the test dataset, we estimate the quantity
1
max ‖δ‖≤
‖g(x+ δ)− g(x)‖∞ (21)
where g is the network and is a small constant taken to be 1/255. The expression (21) is clearly a lower bound of the Lipschitz constant (can be seen as the “local Lipschitz constant” near point x). It can be further lower bounded by using the PGD solution δ = δPGD. We run PGD for each target label j and optimize
1
max ‖δ‖≤
|[g(x+ δ)]j − [g(x)]j | (22)
using 20 PGD steps with step size /4.
Results are shown in Figure 3. It can be observed that the “local Lipschitz constant” around real data points is indeed far larger than one. The average value exceeds 100 which is close to the theoretical upper bound.

heading: D RANDOMIZED SMOOTHING FOR `∞ PERTURBATIONS
text: Randomized smoothing approaches typically provide probabilistic certified guarantees for `2 perturbations. To apply these methods in the `∞ perturbation scenario, most of works convert the result of `2 perturbation into `∞ perturbation using norm inequalities (Salman et al., 2019a; Blum et al., 2020). Specifically, to certify the robustness under -bounded `∞ perturbations, one can certify the robustness under ( √ d)-bounded `2 perturbations to obtain a lower bound estimate where d is the input dimension. On CIFAR-10 dataset, the input dimension d = 3072. This corresponds to an `2 perturbation radius = 0.4347 for `∞ perturbation radius = 2/255, and corresponds to an `2 perturbation radius = 1.739 for `∞ perturbation radius = 8/255.
For the case = 2/255, Blum et al. (2020) directly reported a certified accuracy of 62.6% using randomized smoothing which is currently state-of-the-art. For the case = 8/255, there are no literature results that directly report `∞ robustness, so we use the results of `2 robustness from representative papers (Salman et al., 2019a; Jeong & Shin, 2020). Salman et al. (2019a) reported a certified accuracy of 24% and a clean accuracy of 53% under `2 perturbation = 1.75 (Table 17 in their paper). Jeong & Shin (2020) reported a certified accuracy of 25.2% and a clean accuracy of 52.3% under `2 perturbation = 1.75 (Table 1 in their paper, σ = 0.5). For the case = 16/255, all randomized smoothing methods fail and only achieve a trivial certified accuracy of 10%.

heading: E ABLATION STUDIES
text: In this section we conduct ablation experiments to the proposed loss. Let a training sample be (x, y) where y is the label of x, and denote g(x) as the output of an `∞-distance net for input x. Let `hinge(z, y) = max{maxi 6=y zi − zy + 1, 0} and `CE(z, y) = log( ∑ i exp(zi)) − zy represent the hinge loss and cross-entropy loss, respectively. We would like to justify that (i) Cross-entropy loss can alleviate the optimization issue in `p-relaxation (which is a better substitute over hinge loss), but the threshold of hinge loss is also crucial as it explicitly optimizes the certified accuracy; (ii) Combining cross-entropy loss and clipped hinge loss leads to a much better performance; (ii) Using a decaying mixing coefficient λ can further boost the performance and stabilize the training.
We consider the following objective functions:
(1) The baseline hinge loss: `hinge(g(x)/θ, y) with hinge threshold θ. This loss is used in Zhang et al. (2021).
(2) The cross-entropy loss: `CE(s · g(x), y) where s is a scalar (temperature). Note that the information of the allowed perturbation radius is not encoded in the loss, and the loss only coarsely enlarges the output margin (see Section 4.2). Therefore it may not achieve desired certified robustness.
(3) A variant of cross-entropy loss with threshold: `CE(s · g(x − θ1y), y) where s is a scalar (temperature), θ is the threshold hyper-parameter and 1y is the one-hot vector with the yth element being one. Intuitively speaking, we subtract the yth output logit by θ before taking cross-entropy loss. Compared to the above loss (2), now the information is encoded in the threshold hyper-parameter θ. We point out that this loss can be seen as a smooth approximation of the hinge loss.
(4) The combination of cross-entropy loss and clipped hinge loss: λ`CE(s · g(x), y) + min(`hinge(g(x)/θ, y), 1) with a fixed mixing coefficient λ.
(5) The combination of cross-entropy loss and clipped hinge loss: λ`CE(s · g(x), y) + min(`hinge(g(x)/θ, y), 1) with a decaying λ. The loss is used in this paper.
We keep the training procedure the same for the different objective functions above. The hyperparameters such as θ and λ are independently tuned for each objective function to achieve the best certified accuracy. The scalar s is a learnable parameter in each loss except for objective function (2) where we tune the value of s. For other hyper-parameters, we use the values in Table 3. We independently run 5 experiments for each setting and the median of the performance is reported. Results are listed in Table 5, and the bracket in Table 5(b) shows the standard deviation over 5 runs.
We can draw the following conclusions from Table 5:
• Hinge loss and cross-entropy loss are complementary. Cross-entropy is better in the early training phase when the Lipschitz constant is large, while hinge loss is better for certified robustness when the model is almost 1-Lipschitz in the later training phase. This can be seen from the results of objective functions (1-3) in Table 5(a), where (3) incorporates cross-entropy loss and the threshold in hinge loss, and outperforms both (1) and (2) by a comparable margin.
• Combining cross-entropy loss and clipped hinge loss leads to much better performance. This can be seen from the result of the objective function (4), which significantly outperforms (1-3). However, this loss is very sensitive to the hyper-parameter λ as is demonstrated in Table 5(b). If λ is too large, the certified accuracy gets worse. If λ is too small, the training becomes unstable and the clean accuracy drops significantly. In the extreme case when λ = 0, the loss (4) reduces to the clipped hinge loss and the optimization fails because clipped hinge loss does not optimize for wrongly-classified samples.
• Using a decaying mixing coefficient λ can further boost the performance and stabilize the training. In contrast to the loss (4), we will show in Appendix F that the proposed objective function (5) in this paper is not sensitive to hyper-parameter λ.

heading: F SENSITIVITY ANALYSIS
text: In this section we provide sensitive analysis of the proposed objective function (9) with respect to hyper-parameters. We consider the setting = 8/255 on CIFAR-10 dataset. For each choice of hyper-parameters, we independently run 3 experiments and the median of the certified accuracy is reported.
The hinge threshold θ. The results are already plotted in Figure 2(b). We list the concrete numbers below.
The mixing coefficients λ0 and λend. The results are already shown in Figure 2(c).
The number of epochs. Our best result reported in Table 2 is trained for 1300 epochs, which is longer than Zhang et al. (2021). We also consider using the same training budget by setting e1 = 100, e2 = 650, e3 = 50 in Table 3. This yields a total of 800 training epochs. In this way we can achieve 54.52 clean accuracy and 39.61 certified accuracy.
Adam hyper-parameters. While we use the same Adam hyper-parameters as Zhang et al. (2021), note that the values are different from the default numbers in Pytorch (e,g. β2 = 0.999 and = 10−8). Instead, we use β2 = 0.99 and = 10−10 in all experiments.
For , we find the value is essential to be small, because for the `p-distance function, the gradients of most of the elements are close to zero when p is large. For Adam optimizer (Kingma & Ba, 2015), the update is written as
wt+1 = wt − lr · mt√ vt + . (23)
Then a large will dominate the denominator in Adam if vt is close to zero, which severely weakens the parameters’ update and leads to worse performance. We find the value of is not sensitive if it is small enough, i.e. we can obtain almost identical performance for = 10−10, 10−11 or 10−12.
The use of a smaller β2 is mainly because of the `p relaxation. Since p increases exponentially during training, the network function changes through time, therefore the long-time-ago historical gradient information will become meaningless and even do harm to the training. This is why a smaller β2 is used, so that the second-order momentum (the term vt) in Adam only depends on recent gradient information. We find it is also OK to choice β2 =0.98 or 0.995, and the certified accuracy can reach 39.5%. However, the default value of 0.999 is too large, as it corresponds to 10 times more historical information than the value of 0.99.

Review summaries:
This paper proposed a simple modification of $\ell_\infty$ net training, which boosts the accuracy for certified robustness under $\ell_\infty$ attack. It provides a trainable scale on the output of the network and uses a clipped hinge loss. The paper also proves the expressive ability of $\ell_\infty$ nets for classification problems.

This paper is a follow-up paper of Zhang et al. (2021). In Zhang et al. (2021), the authors proposed a new network architecture, l_infty distance net. By construction, the network is 1-Lipschitz w.r.t. l_infty distance. However, the training procedure therein is problematic. This paper resolves the issue by a new loss design of scaled cross entropy loss + clipped hinge loss. Without using MLP on top of the l_infty distance net backbone, the proposed new training method outperforms the original one in Zhang et al. (2021) and improves over the state-of-the-art by more than 5% for 8/255 and other radiuses. Theoretically, the paper shows the expressive power of l_infty distance net for well-separated data.