Year: 2019

Abstract:
We propose a novel framework for avoiding the misclassification of data by using a framework of learning with rejection and adversarial examples. Recent developments in machine learning have opened new opportunities for industrial innovations such as self-driving cars. However, many machine learning models are vulnerable to adversarial attacks and industrial practitioners are concerned about accidents arising from misclassification. To avoid critical misclassifications, we define a sample that is likely to be mislabeled as a suspicious sample. Our main idea is to apply a framework of learning with rejection and adversarial examples to assist in the decision making for such suspicious samples. We propose two frameworks, learning with rejection under adversarial attacks and learning with protection. Learning with rejection under adversarial attacks is a naive extension of the learning with rejection framework for handling adversarial examples. Learning with protection is a practical application of learning with rejection under adversarial attacks. This algorithm transforms the original multi-class classification problem into a binary classification for a specific class, and we reject suspicious samples to protect a specific label. We demonstrate the effectiveness of the proposed method in experiments.

heading: 1 INTRODUCTION
text: Recent machine learning models have achieved great success in applications such as self-driving cars (Bojarski et al., 2016) and medical diagnosis (Litjens et al., 2017). In a classification problem, we sometimes face the situation where the misclassification of a specific label can result in serious accidents. This problem arises in various situations, and below we provide examples.
Example 1 (Object Detection for Self-Driving Cars). For self-driving cars, object detection is crucial. For protecting the life of pedestrians, self-driving cars need to be able to detect human or suspend decision making if it detects an object that might be a human.
Example 2 (Medical Diagnosis). Cancer is one of the leading causes of death globally, and machine learning algorithms for detecting cancer from images have been gaining attention. This is done by detecting abnormalities in an image that might indicate cancer.
As shown above, we want the labeling of data to be conservative for certain situations; for example, in autonomous driving, it is better to misclassify a non-human object as a human than to risk misclassifying a human. In this paper, we introduce two novel frameworks called learning with rejection under adversarial attacks and learning with protection to protect a specific class from critical misclassification. Our algorithm is based on the techniques of learning with rejection and adversarial examples. Learning with rejection under adversarial attacks is a naive extension of learning with rejection to hold a decision when we face a suspicious sample that is vulnerable to adversarial attack. Learning with protection is an application of learning with rejection under adversarial attack. The purpose is to protect a specific class from misclassification. Both frameworks are based on the existing work of learning with rejection and adversarial examples.
Learning with rejection is a classification scenario where the learner is given the option to reject an instance instead of predicting its label. The purpose of this framework is to prevent critical
misclassification, where rejecting labeling a datum incurs a lower cost than misclassification. In this field, considerable theoretical and empirical analysis has been conducted (Bartlett & Wegkamp, 2008; Cortes et al., 2016a;b; Grandvalet et al., 2009; Herbei & Wegkamp, 2006; Yuan & Wegkamp, 2010). Learning with rejection is one ultimate solution against data with high uncertainty. However, the existing frameworks have not considered adversarial examples, which refers to a well-designed attack to mislead people to misclassification.
In the industrial application of machine learning, it has been observed that many machine learning models are vulnerable to adversarial attacks. Threat model of adversarial attacks specifies the capabilities of the adversary and classifies adversary attacks to two types of attacks, white-box attack and black-box attack. Adversarial inputs that result in machine learning models returning incorrect outputs are called adversarial examples. Several previous studies have artificially generated adversarial examples by adding small perturbations that are imperceptible to humans (Goodfellow et al., 2015; Gu & Rigazio, 2014; Huang et al., 2015; Carlini & Wagner, 2017). Methods for protecting against these adversarial examples are also being proposed. Among them, adversarial training is one of the most effective defenses (Szegedy et al., 2014; Goodfellow et al., 2015; Shaham et al., 2015; Carlini & Wagner, 2016; Papernot et al., 2016; Xu et al., 2017; Madry et al., 2018; Buckman et al., 2018; Kannan et al., 2018; Pang et al., 2018; Wong & Kolter, 2018; Tramèr et al., 2018).
However, most of the defense method fails to avoid misclassification under adversarial attacks. Carlini & Wagner (2017) defeated representative methods for detection of adversarial examples. Athalye et al. (2018) reports that several defense algorithms for white-box setting fail when the attacker uses a carefully designed gradient-based method. Besides, Shafahi et al. (2019); Gilmer et al. (2019) shows that adversarial examples are inevitable in some cases. However, we sometimes face situations in which misclassification can result in fatal accidents. For that purpose, we propose learning with rejection option under adversarial attack. The main idea of our method is to hold a decision when we get suspicious samples. As an application of learning with a rejection option, we propose a method for preventing the misclassification of data for a specific label under adversarial examples. This method considers situations where we must protect our model from adversarial examples by any means. In addition, It should be noted that our method can be combined with other existing methods such as adversarial training. In the following section, we describe the problem setting. In Sections 3 and 4, we propose and describe our algorithm, and in Section 5, we show the experimental results.

heading: 2 PROBLEM SETTING
text: We use the standard settings for binary classification problems, i.e., training and test data points are i.i.d. and sampled from some unknown distribution D over X × {−1,+1}, where X denotes the input space. The goal is to learn a classifier h : X → {−1,+1} that assigns a label ŷ(x) to a datum x as ŷ(x) = sign(h(x)). Let L be a loss function L : R× {−1,+1} → R. The optimal classifier h∗ is given by h∗ = argminh∈F E[L(h(X), Y )], where F is a set of measurable functions. When we train a classifier with training samples, we can naively replace the expectation with the corresponding sample averages. For a hypothesis set H, let us define an estimator of the optimal classifier h∗ as ĥ = argminh∈H Ê[L(h(X), Y )], where Ê denotes the averaging operator over training data. Although an estimator ĥ converges to h∗ in many cases with infinite samples, an estimator ĥ might return result that differ greatly from h∗ in a case with finite samples. In addition, when h(x) is not smooth at around x, it might become difficult to estimate the function. These can cause serious problems in real-world applications, such as traffic accidents arising from misclassification by the algorithms used in self-driving cars. To make our algorithm’s inference more robust, we allow a learner to reject such suspicious samples. Let R© denote rejection. For any given instance x ∈ X , the learner has the option of abstaining from assigning a label or rejecting that instance and returning the symbol R©, or assigning the label ŷ ∈ {−1,+1}. If the learner rejects an instance, then they incur some loss c(x) ∈ R; if it does not reject but assigns an incorrect label, then it incurs a cost of one; otherwise, it suffers no loss. Thus, the learner outputs a rejection function r : X → R, that determines the points x ∈ X to be rejected according to r(x) ≤ 0. Let us denote a loss function with rejection option L R© : R× {−1,+1} → R. For example, a loss function can be defined as follows:
L R©(h(x), y) = 1yh(x)≤01r(x)≥0 + c(x)1r(x)≤0.
There are two frameworks used in the learning with rejection model: the confidence-based and separation-based approaches Cortes et al. (2016a). The separation-based approach is first formulated by Cortes et al. (2016a). This formulation is a generalization of confidence-based approach (Bartlett & Wegkamp, 2008). In the separation-based approach, we train a classifier and a rejection function simultaneously. In confidence-based approach, given the conditional probability p(y = +1|x) and a cost function c(x), we only train a classifier and obtain a rejection function automatically after training a classifier. Although the confidence-based approach is a special case of the separation-based approach, the method of confidence-based approach is easy to implement. In this paper, we follow the confidence-based approach and correspond the cost function to vulnerability for adversarial examples.
Our goal is to obtain the optimal classifier h∗, which minimizes the classification risk with rejection option, i.e., h∗ = argminh∈H E[L R©(h(X), Y )].

heading: 3 LEARNING WITH REJECTION UNDER ADVERSARIAL ATTACKS
text: In this section, we describe a method to hold a decision against suspicious samples.

heading: 3.1 STRATEGY FOR REJECTING SUSPICIOUS SAMPLES
text: To reject suspicious samples, we define which samples are suspicious. We introduce a concept of a p-norm suspicious sample. Let ‖ · ‖p be `p-norm. We refer a sample x as suspicious based on the value of `p-norm if there exits a sample x′ such that ‖x − x′‖p ≤ ε and ĥ(x′) returns a different class from ĥ(x). If a sample is suspicious, we refrain from assigning a class label.
Suppose that we have a estimator f̂(x) of the class conditional probability η(x) = p(y = +1|x) and a classifier ĥ(x) = sign ( f̂(x)− 12 ) . Let B∞x ( ) denote the `p ball centered at x ∈ X with radius , i.e., Bpx( ) = {x′ ∈ X : ‖x′ − x‖p ≤ }. We calculate z∗(x) ∈ Bpx( ) as follows:
z∗(x) = argmax x′∈Bpx( ) L̃(ĥ(x′),x).
By defining z∗(x) as in the above equation, we can easily calculate it with the techniques used in adversarial examples. If ĥ(z∗(x))ĥ(x) ≤ 0 for a sample x, we regard the sample as suspicious one. We illustrate the concept in Figure 1.

heading: 3.2 RELATIONSHIP WITH LEARNING WITH REJECTION
text: To interpret the above strategy, we consider the relationship between the strategy and learning with rejection. First, we consider the ideal situation, where we know the true value of the conditional class probability η(x) = p(y = +1|x). In confidence-based approach, we can determine the rejection function r(x) corresponding to the rejection cost as shown by Cortes et al. (2016a). It is known that the classifier h∗ defined for any x ∈ X by h∗(x) = η(x) − 12 is optimal. For any x ∈ X , the misclassification cost for h∗ is E [ 1yh(x)≤0|x ] = min{η(x), 1− η(x)}. The optimal rejection
function r∗(x) should therefore be defined such that r∗(x) ≤ 0 if and only if
min{η(x), 1− η(x)} ≥ c(x)⇔ 1−max{η(x), 1− η(x)} ≥ c(x)⇔ |h(x)| ≤ 1 2 − c(x).
Therefore, the optimal rejection function r∗(x) is given as r∗(x) = |η(x)− 12 | − ( 1 2 − c(x) ) . Thus, in confidence-based approach, we can determine the optimal rejection function r∗(x) if we know the conditional probability η(x) and the rejection cost c(x).
To reject suspicious samples, we relate the rejection cost c(x) with uncertainty of data x. One naive idea is to set c(x) as a monotonically decreasing function representing the smoothness of η(x). When |η(x)− η(x′)| is zero for x,x′ ∈ Rd, c(x) takes its largest value; when max |f(x)− f(x′)| is large, c(x) is small. This means that, if a sample x is suspicious, then the cost of rejection is low, and we can reject the sample easily; conversely, if a sample x is not suspicious, then the cost of rejection is high. When the cost is high, we hesitate to reject the sample. We assumed this condition could be met when designing our algorithm. As we show later, we can easily find such c(x) and reject suspicious samples without expending much energy in determining the value of c(x). In our strategy, we reject a sample x such that (
η(z∗(x))− 1 2
)( η(x)− 1
2
) ≤ 0.
Therefore, r∗(x) ≤ 0 if and only if( η(z∗(x)) ≤ 1
2 and η(x) ≥ 1 2
) or ( η(z∗(x)) ≥ 1
2 and η(x) ≤ 1 2 ) ⇔ ( η(x)− η(x) + η(z∗(x)) ≤ 1
2 and η(x) ≥ 1 2
) or ( η(x)− η(x) + η(z∗(x)) ≥ 1
2 and η(x) ≤ 1 2 ) ⇔ ( 0 ≤ η(x)− 1
2 ≤ η(x)− η(z∗(x))
) or ( η(x)− η(z∗(x)) ≤ η(x)− 1 2 ≤ 0 )
(1)
Let us assume that η(x) − η(z∗(x)) ≥ 0 when η(x) − 12 ≥ 0 and η(x) − η(z ∗(x)) ≤ 0 when η(x)− 12 ≤ 0. Then, (1) insists that r ∗(x) ≤ 0 if and only if |h(x)| ≤ |η(x)−η(z∗(x))|. Therefore, the following relationship holds for a sample x such that |η(x)− η(z∗(x))| ≤ 12 :
c(x) = 1
2 − |η(x)− η(z∗(x))|.
Thus, in our strategy, the cost function is a decreasing function of the smoothness of η(x).
Next, we show a relationship between the cost function and the degree of perturbation ε. Let us assume η(x) is Lipschitz continuous, with `p-norm, and |η(x)− η(x′)| ≤ λ‖x− x′‖p = λε, wherex ∈ X , x′ ∈ Bpx( ), and λ > 0 is a positive constant. From Lipschitz continuity, c(x) ≥ 12−λε holds. This means that the cost of rejection will be small when ε is a large value. Therefore, a learner can reject a sample with low cost when the learner is afraid of the misclassification and set the possible perturbation of x with `p-norm large.

heading: 3.3 ALGORITHM
text: Based on the above idea, we develop an algorithm for rejecting suspicious samples. To discuss learning the rejection in the framework of confidence-based approach, we construct an estimator f̂ of η(x) = p(y = +1|x) and a classifier ĥ(x) = f̂(x) − 12 . Then, we define pseudo loss function L̃ for two samples x ∈ X and x′ ∈ Bpx( ) as a binary loss function for a pair of (x′, ŷ(x), where ŷ(x) = sign(ĥ(x)). For example, if we assume logistic loss, it can be defined as
L̃(f̂(x′), ŷ(x)) = −1ŷ(x)=−1 log ( f̂(x) ) − 1ŷ(x)=+1 log ( 1− f̂(x) ) .
Using the pseudo loss, we calculate z∗(x) for a sample x as follows:
z∗(x) = argmax x′∈Bpx( ) L̃(ĥ(x′), ŷ(x)).
Because this optimization is hard to calculate, we apply techniques of adversarial examples as a heuristics. Then, we reject a sample x if and only if ĥ(z∗(x))ĥ(x) ≤ 0.
Calculation of Adversarial Examples: Here, we describe the two simple first-order methods for calculating adversarial examples used in this paper. Although various types of adversarial examples have been proposed, hereinafter adversarial examples refer to perturbation-based methods.
One of the simplest methods for generating adversarial examples is the fast gradient sign method (FGSM) Goodfellow et al. (2015), which is a fast single-step attack that maximizes the loss function in the linear approximation. The perturbation under the FGSM is calculated as follows:
δ = ε · sign(∇xL(h(x), y)).
The projected gradient descent method (PGD) Madry et al. (2018) is an iterative variant of the FGSM. The perturbation under the PGD at time step s+ 1 is calculated as follows:
δ(s+1) = Pε(δ(s) + α · sign(∇xL(h(x+ δ(s)), t))), where α denotes a single step and Pε(·) denotes the projection onto the `p-ball with radius ε.

heading: 4 LEARNING WITH PROTECTION
text: In this section, we propose a practical and easily implemented algorithm as an application of learning with rejection under adversarial attack. In many cases, we want to avoid misclassification for a specific class. In self-driving cars, we must be able to detect human beings to avoid serious accidents. In medical diagnosis, we should not miss a dangerous disease. We thus propose an algorithm to protect a specific class from misclassification in a multi-class classification problem.
We extend the previous problem setting of binary classification to that of multi-class classification. Let X and Y be the feature and label spaces, respectively, and suppose that there is an unknown distributionD overX×Y . We assume that the label space hasK ≥ 2 labels, i.e., Y = {1, 2, 3, ...,K}. We define the class for which we want to avoid misclassification as the defense target class t ∈ Y . For example, if we want to avoid misclassification of 1, we designate the defense target class as t = 1. We call the algorithm for protecting a defense target class based on the following idea learning with protection.

heading: 4.1 PROTECTING A DEFENSE TARGET CLASS
text: Let F be the set of measurable functions from X × Y to R. For a function f ∈ F , we define a classifier hf : X × Y → R as follows:
yf (x) = argmax k∈[K] f(x, y = k).
Let L(f ;x, y) be the loss function of a function f ∈ F for data (x, y). The goal of the learning problem is to find f ∈ F such that the population riskR(f) := E(x,y)∈D[L(f ;x, y)] is minimized. This formulation is the standard setting of multi-class classification problem.
From the original formulation of the multi-class classification problem, we construct a binary classification problem to protect the defense target class t from misclassification. Let us define a function ybf : X → {−1,+1} for a function f to transform the prediction of multi-class classification to that of binary classification as
ybf (x) =
{ +1 yf (x) = t
−1 yf (x) 6= t .
For a pair (x, ybf (x)), we calculate a new feature z ∗(x) as follows:
z∗(x) = argmax x′∈Bpx( ) L̃(f ;x′, ybf (x)), (2)
where L̃f (f ;x′, ybf (x)) is a binary loss function for a pair (x, ybf (x)). This loss function corresponds to the pseudo loss function introduced in the previous section. For example, we can define 0-1 loss as follows: L̃(f ;x′, ybf (x)) = 1ybf (x)=−11ybf (x′)=+1 + 1ybf (x)=+11ybf (x′)=−1. Then, for this binary classification problem derived from multi-class classification problem, we apply an algorithm for rejection. If yf (z∗(x)) = t for a sample x such that yf (x) 6= t, then we reject the sample because the sample x predicted as a class that is not t might be a class t in neighborhood of x with `p-norm. We call algorithms based on the abeve idea learning with protection.
Algorithm 1 Learning with Protection Input: Trained classier ĥ, defense target class t ∈ [K], and test dataset {xi}ni=1. Construct a pseudo loss function (3) for test dataset {xi}ni=1. Compute z∗(xi) for a sample xi by (2) by method of adversarial example. Reject a sample xi if ĥ(xi) 6= t and ĥ(z∗(xi)) = t

heading: 4.2 ALGORITHM WITH CROSS-ENTROPY LOSS
text: Various algorithms can be used to implement the above framework. In this section, we consider a cross-entropy loss function and define an algorithm for protecting the defense target class.
LetH be a hypothesis set. First, we train a model f ∈ H with the cross-entropy loss by any of the suitable methods for classification problems such as adversarial training. After training g, we obtain f̂ , the function that minimizes the cross-entropy loss. The trained model is an estimator of the risk minimizer f∗ on population. Second, we use the logistic loss for L̃, i.e.,
L̃(f ;x′, ybf (x)) =− 1ybf (x)=−1 log
( exp (f(x′, y = t))∑
k∈[K] exp (f(x ′, y = k))
)
− 1ybf (x)=+1 log
( 1− exp (f(x
′, y = t))∑ k∈[K] exp (f(x ′, y = k))
) . (3)
The intuition of this loss function is as follows. Let g∗(x′, t) = exp(f∗(x′,y=t))∑
k∈[K] exp(f ∗(x′,y=k)) . Under a
cross entropy loss function, we can interpret g∗(x′, k) as p(y = k|x′) with g∗. Therefore, we can apply the log loss function function with g∗(x′, t) = p(y = t|z) and p(y 6= t|z) = 1−p(y = t|z) = 1− g∗(x′, t). As mentioned above, to find a feature z∗ from (2), we can apply methods of adversarial examples as a heuristics. We show the pseudo algorithm in Algorithm 1.

heading: 5 EXPERIMENTS
text: To demonstrate the effectiveness of proposed method, we conducted experiments using benchmark data. For the benchmark data, we use the CIFAR-101) (Krizhevsky, 2009) and ImageNet-1002) (Kang et al., 2019) dataset. The CIFAR-10 dataset consists of 32×32 color images in 10 classes, with 6, 000 images per class. There are 50, 000 training images and 10, 000 test images. The ImageNet-100 dataset consists of the 100-class subset of ImageNet-1K (Deng et al., 2009; Russakovsky et al., 2015) containing every 10th class by WordNet ID order. As we explained above, learning with protection rejects suspicious samples after we train a model f̂ to protect defense target class. For CIFAR-10, we set airplane class as defense target class. For ImageNet-A, we set the first 10 classes in the order of WordNet ID as defense target class. Our method allow various training method to estimate f∗. When we train the model f̂ , we used both standard training method and adversarial training (Madry et al., 2018). After trainning a model, we adopt 30-step `∞ bounded PGD attack to find the feature z∗. For each experiment, we output the accuracy, precision, recall, rejection rate, and true rejection. Let TP, TN, FP, and FN be the numbers of true positive, true negative, false positive, and false negative of a classification result. Then, accuracy, precision, and recall are defined as accuracy = TP+TNTP+TN+FP+FN , precision = TP TP+FP , and recall = TP TP+FN . Let true accept (TA) be an outcome where the rejection function correctly accepts data such that a sample x does not belong to the defense target class, i.e., h(x) 6= t. Let true reject (FR) be an outcome where the rejection function correctly rejects data such that a sample x belongs to the defense target class, i.e., h(x) = t. FA and FR can be defined similarly (Ni et al., 2019). Then, rejection rate and precision of rejection are defined as rejection rate = TR+FRTR+TA+FR+FA and precision of rejection = TR TR+FR .
1)See https://www.cs.toronto.edu/~kriz/cifar.html. 2)See http://image-net.org/index.
Neural network model: For CIFAR-10, we use the ResNet-56 (He et al., 2015) architecture. For ImageNet-100, we use the ResNet-50 (He et al., 2015) architecture with 224 × 224 resolution as implemented in torchvision. We describe training hyperparameters in Appendix A.
Adversarial training: We use `∞ bounded projected gradient descent (PGD) method to generate training samples. We select a attack target class for each image uniformly at random from the set of incorrect classes. For distortion size ε, we set as ε = 8/255 and apply random scaling Uniform(0, ε) to improve performance against smaller distortions. We use 10 optimization steps and step size ε/ √ steps as described in (Kang et al., 2019). We update the model by stochastic gradient descent (SGD) method using only the adversarial images (no clean images).

heading: 5.1 PROTECTION AGAINST ARTIFICIAL ADVERSARIAL EXAMPLES
text: We evaluate our learning with protection method on the CIFAR-10 and ImageNet-100 validation sets against artificial adversarial examples with the defense target class.
protection against expected attack: We distort the inputs by 50-step `∞ bounded PGD attack and apply learning with protection method. The single step size of PGD is calculated by ε/ √ steps. The results are shown in Table 1 and Appendix B.1.
protection against unexpected attack: Although in our learning with protection method, a specific adversarial attack method is used to find the feature z∗(xi) for a sample xi (we adopt `∞ bounded PGD in this experiment), the input might be distorted by different attack methods. In order to evaluate the performance against such unexpected adversaries, we conducted experiments against 50-step l2 bounded PGD attack. The results are shown in Table 2 and Appendix B.1.
We can see from the table that our method achieves 100% in the recall, i.e., we can reject all samples such that y = t and h(x) 6= t. As shown in Appendix B.1, models with adversarial training outperforms models without adversarial training. It is because our method only reduce the false negative, and it is difficult to improve the performance of a model when the number of the true positive is small. When we use adversarial training, we can increase the recall with the small number of rejection. For example, in Table 2, when attack is `2 bounded PGD (ε = 80) for CIFAR-10, recall increases about 20% by only reject 9.14% of all samples. On the other hand, On the other hand, when we reject too many samples, the precision of rejection dramatically drops. Therefore, we need to control the perturbation ε not to reject samples unnecessarily.

heading: 5.2 PROTECTION AGAINST NATURAL ADVERSARIAL EXAMPLES
text: Natural adversarial examples which are introduced in (Hendrycks et al., 2019) are defined as unmodified and naturally occurring examples that cause classifier accuracy to degrade drastically. In order to evaluate the proposed method for such real hard samples, we conduct experiments on ImageNet-A3)
3)See https://github.com/hendrycks/natural-adv-examples.
dataset. ImageNet-A contains 7,500 natural adversarial example images in 200 classes that are a subset of ImageNet-1K’s 1,000 classes. We use the ResNet-50 architecture with 224× 224 resolution. We first trained the model on the training set of ImageNet-1K dataset and evaluate the performance on ImageNet-A with our learning with protection method at test time. Due to the difference in the number of classes, only 200 of its 1,000 logits are used in test time. We set the first 20 classes in the order of WordNet ID as the defense target class. The results are shown in Table 3.
As shown in Table 3 and Appendix B.2, the proposed method works well for natural adversarial samples. For example, when the distortion size is 2/255, the recall increases about 20% by rejecting only 30% of all samples. On the other hand, the rejection rate of the models without adversarial training is high even when the size of the perturbation ε is small.

heading: 6 CONCLUSION
text: In this paper, we proposed learning with rejection under adversarial attacks for avoiding the misclassification. The proposed method suspend decision making when a sample is `p-norm suspicious. By extending the strategy, we proposed an easily implementable algorithm called learning with protection. This algorithm prevents a defense target class from misclassification. We showed the performance of learning with protection using benchmark datasets. From the results, we confirmed that our method successfully caught samples that would have misclassified if we did not reject it.

heading: A TRAINING HYPERPARAMETERS
text: For CIFAR-10, we trained on a single NVIDIA V100 GPU for 200 epochs with batch size 32, initial learning rate 0.1, momentum 0.9, and weight decay 10−4. We decayed the learning rate at epochs 100 and 150. For ImageNet-100, we trained on machines with 8 NVIDIA V100 GPUs using standard data augmentation used in (He et al., 2015). We ran synchronized SGD (Goyal et al., 2017) for 90 epochs with batch size 32× 8 and a learning rate schedule with 5 “warm-up” epochs and a decay at epochs 30, 60, and 80 by a factor of 10.

heading: B FULL EXPERIMENTAL RESULTS
text: B.1 PROTECTION AGAINST ARTIFICIAL ADVERSARIAL EXAMPLES
B.2 PROTECTION AGAINST NATURAL ADVERSARIAL EXAMPLES

Review summaries:
This paper wants to study the problem of “learning with rejection under adversarial attacks”. It first naively extends the learning with rejection framework for handling adversarial examples. It then considers the classical cost-sensitive learning by transfer the multi-class problem into binary classification problem through one-vs-all and using the technique they proposed to reject predictions on non-important labels, and name such technique as “learning with protection”. Finally, they do some experimental studies.