Add files using upload-large-folder tool

parse/train/B1eksh4KvH/B1eksh4KvH.md

@@ -0,0 +1,258 @@
+# CURRICULARFACE: ADAPTIVE CURRICULUM LEARN-ING LOSS FOR DEEP FACE RECOGNITION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+As an emerging topic in face recognition, designing margin-based loss functions can increase the feature margin between different classes for enhanced discriminability. More recently, absorbing the idea of mining-based strategies is adopted to emphasize the misclassified samples and achieve promising results. However, during the entire training process, the prior methods either do not explicitly emphasize the sample based on its importance that renders the hard samples not fully exploited; or explicitly emphasize the effects of semi-hard/hard samples even at the early training stage that may lead to convergence issue. In this work, we propose a novel Adaptive Curriculum Learning loss (CurricularFace) that embeds the idea of curriculum learning into the loss function to achieve a novel training strategy for deep face recognition, which mainly addresses easy samples in the early training stage and hard ones in the later stage. Specifically, our CurricularFace adaptively adjusts the relative importance of easy and hard samples during different training stages. In each stage, different samples are assigned with different importance according to their corresponding difficultness. Extensive experimental results on popular benchmarks demonstrate the superiority of our CurricularFace over the state-of-the-art competitors. Code will be available upon publication.
+
+# INTRODUCTION
+
+The success of Convolutional Neural Networks (CNNs) on face recognition can be mainly credited to : enormous training data, network architectures, and loss functions. Recently, designing appropriate loss functions that enhance discriminative power is pivotal for training deep face CNNs.
+
+Current state-of-the-art face recognition methods mainly adopt softmax-based classification loss. Since the learned features with the original softmax is not discriminative enough for the open-set face recognition problem, several margin-based variants have been proposed to enhance features’ discriminative power. For example, explicit margin, i.e., CosFace (Wang et al., 2018a), Sphereface (Li et al., 2017), ArcFace (Deng et al., 2019), and implicit margin, i.e., Adacos (Zhang et al., 2019a), supplement the original softmax function to enforce greater intra-class compactness and inter-class discrepancy, which are shown to result in more discriminate features. However, these margin-based loss functions do not explicitly emphasize each sample according to its importance.
+
+As demonstrated in Chen et al. (2019), hard sample mining is also a critical step to further improve the final accuracy. Recently, Triplet loss (Schroff et al., 2015) and SV-Arc-Softmax (Wang et al., 2018b) integrate the motivations of both margin and mining into one framework for deep face recognition. Triplet loss adopts a semi-hard mining strategy to obtain semi-hard triplets and enlarge the margin between triplet samples. SV-Arc-Softmax (Wang et al., 2018b) clearly defines hard samples as misclassified samples and emphasizes them by increasing the weights of their negative cosine similarities with a preset constant. In a nutshell, mining-based loss functions explicitly emphasize the effects of semi-hard or hard samples.
+
+However, there are drawbacks in training strategies of both margin- and mining-based loss functions. For margin-based methods, mining strategy is ignored and thus the difficultness of each sample is not fully exploited, which may lead to convergence issues when using a large margin on small backbones, e.g., MobileFaceNet (Chen et al., 2018). As shown in Fig. 1, the modulation coefficient for the negative cosine similarities $I ( \cdot )$ is fixed as a constant 1 in ArcFace for all samples during the entire training process. For mining-based methods, over-emphasizing hard samples in early training stage may hinder the model to converge. As SV-Arc-Softmax claimed, the manually defined constant $t$ plays a key role in the model convergence property and a slight larger value (e.g., ${ > } 1 . 4$ ) may cause the model difficult to converge. Thus $t$ needs to be carefully tuned.
+
+![](images/26d2e0767b65dd67f07c9b1c61156c4365d57d1148bf6246b32fab974d2aa629.jpg)  
+Figure 1: Different training strategies for modulating negative cosine similarities of hard samples (i.e., the mis-classified sample) in ArcFace, SV-Arc-Softmax and our CurricularFace. Left: The modulation coefficients $I ( t , \cos \theta _ { j } )$ for negative cosine similarities of hard samples in different methods, where $t$ is an adaptively estimated parameter and $\theta _ { j }$ denotes the angle between the hard sample and the non-ground truth $j$ -class center. Right: The corresponding hard samples’ negative cosine similarities $N ( t , \cos \theta _ { j } ) = I ( t , \cos \theta _ { j } ) \cos \theta _ { j } + c$ after modulation, where $c$ indicates a constant. On one hand, during early training stage (e.g., $t$ is close to 0), hard sample’s negative cosine similarities is usually reduced and thus leads to smaller hard sample loss than the original one. Therefore, easier samples are relatively emphasized; during later training stage (e.g., $t$ is close to 1), the hard sample’s negative cosine similarities are enhanced and thus leads to larger hard sample loss. On the other hand, in the same training stage, we modulate the hard samples’ negative cosine similarities with $\cos \theta _ { j }$ . Specifically, the smaller the angle $\theta _ { j }$ is, the larger the modulation coefficient should be.
+
+In this work, we propose a novel adaptive curriculum learning loss, termed CurricularFace, to achieve a novel training strategy for deep face recognition. Motivated by the nature of human learning that easy cases are learned first and then come the hard ones (Bengio et al., 2009), our CurricularFace incorporates the idea of Curriculum Learning (CL) into face recognition in an adaptive manner, which differs from the traditional CL in two aspects. First, the curriculum construction is adaptive. In traditional CL, the samples are ordered by the corresponding difficultness, which are often defined by a prior and then fixed to establish the curriculum. In CurricularFace, the samples are randomly selected in each mini-batch, while the curriculum is established adaptively via mining the hard samples online, which shows the diversity in samples with different importance. Second, the importance of hard samples are adaptive. On one hand, the relative importance between easy and hard samples is dynamic and could be adjusted in different training stages. On the other hand, the importance of each hard sample in current mini-batch depends on its own difficultness.
+
+Specifically, the mis-classified samples in mini-batch are chosen as hard samples and weighted by adjusting the modulation coefficients $I ( t , c o s \theta _ { j } )$ of cosine similarities between the sample and the non-ground truth class center vectors, i.e., negative cosine similarity $N ( t , c o s \theta _ { j } )$ . To achieve the goal of adaptive curricular learning in the entire training, we design a novel coefficient function $I ( \cdot )$ that is determined by two factors: 1) the adaptively estimated parameter $t$ that utilizes moving average of positive cosine similarities between samples and the corresponding ground-truth class center to unleash the burden of manually tuning; and 2) the angle $\theta _ { j }$ that defines the difficultness of hard samples to achieve adaptive assignment. To sum up, the contributions of this work are:
+
+• We propose an adaptive curriculum learning loss for face recognition, which automatically emphasizes easy samples first and hard samples later. To the best of our knowledge, it is the first work to introduce the idea of adaptive curriculum learning for face recognition. We design a novel modulation coefficient function $I ( \cdot )$ to achieve adaptive curriculum learning during training, which connects positive and negative cosine similarity simultaneously without the need of manually tuning any additional hyper-parameter. • We conduct extensive experiments on popular facial benchmarks, which demonstrate the superiority of our CurricularFace over the state-of-the-art competitors.
+
+# RELATED WORK
+
+Margin-based loss function Loss design is pivotal for large-scale face recognition. Current stateof-the-art deep face recognition methods mostly adopt softmax-based classification loss. Since the learned features with the original softmax loss are not guaranteed to be discriminative enough for open-set face recognition problem, margin-based losses (Liu et al., 2016; Li et al., 2017; Deng et al., 2019) are proposed. Though the margin-based loss functions are verified to obtain good performance, they do not take the difficultness of each sample into consideration, while our CurricularFace emphasizes easy samples first and hard samples later, which is more reasonable and effectiveness.
+
+Mining-based loss function Though some mining-based loss function such as Focal loss (Lin et al., 2017), Online Hard Sample Mining (OHEM) (Shrivastava et al., 2016) are prevalent in the field of object detection, they are rarely used in face recognition. OHEM focuses on the large-loss samples in one mini-batch, in which the percentage of the hard samples is empirically determined and easy samples are completely discarded. Focal loss is a soft mining variant that rectifies the loss function to an elaborately designed form, where two hyper-parameters should be tuned with a lot of efforts to decide the weights of each samples and hard samples are emphasized by reducing the weight of easy samples. The recent work, SV-Arc-Softmax (Wang et al., 2018b) fuses the motivations of both margin and mining into one framework for deep face recognition. They define hard samples as misclassified samples and enlarge the weight of hard samples with a preset constant. Our method differs from SV-Arc-Softmax in three aspects: 1) We do not always emphasize the hard samples, especially in the early training stages. 2) We assign different weights for hard samples according to their corresponding difficultness. 3) There’s no need in our method to manually tune the additional hyper-parameter $t$ , which is estimated adaptively.
+
+Curriculum Learning Learning from easier samples first and harder samples later is a common strategy in Curriculum Learning (CL) (Bengio et al., 2009), (Zhou & Bilmes, 2018). The key problem in CL is to define the difficultness of each sample. For example, Basu & Christensen (2013) takes the negative distance to the boundary as the indicator for easiness in classification. However, the ad-hoc curriculum design in CL turns out to be difficult to implement in different problems. To alleviate this issue, Kumar et al. (2010) designs a new formulation, called Self-Paced Learning (SPL), where examples with lower losses are considered to be easier and emphasized during training. The key differences between our CurricularFace with SPL are: 1) Our method focuses on easier samples in the early training stage and emphasizes hard samples in the later training stage. 2) Our method proposes a novel modulation function $N ( \cdot )$ for negative cosine similarities, which achieves not only adaptive assignment on modulation coefficients $I ( \cdot )$ for different samples in the same training stage, but also adaptive curriculum learning strategy in different training stages.
+
+# THE PROPOSED CURRICULARFACE
+
+PRELIMINARY KNOWLEDGE ON LOSS FUNCTION
+
+The original softmax loss is formulated as follows:
+
+$$
+\mathcal { L } = - \log \frac { e ^ { W _ { y _ { i } } x _ { i } + b _ { y _ { i } } } } { \sum _ { j = 1 } ^ { n } e ^ { W _ { j } x _ { i } + b _ { j } } } ,
+$$
+
+where $x _ { i } \in R ^ { d }$ denotes the deep feature of $i$ -th sample which belongs to the $y _ { i }$ class, $W _ { j } \in R ^ { d }$ denotes the $j$ -th column of the weight $W \in R ^ { d \times n }$ and $b _ { j }$ is the bias term. The class number and the embedding feature size are $n$ and $d$ , respectively. In practice, the bias is usually set to $b _ { j } = 0$ and the individual weight is set to $| | W _ { j } | | = 1$ by $l _ { 2 }$ normalization. The deep feature is also normalized and re-scaled to $s$ . Thus, the original softmax can be modified as follows:
+
+$$
+\mathcal { L } = - \log \frac { e ^ { s ( \cos \theta _ { y _ { i } } ) } } { e ^ { s ( \cos \theta _ { y _ { i } } ) } + \sum _ { j = 1 , j \neq y _ { i } } ^ { n } e ^ { s ( \cos \theta _ { j } ) } } .
+$$
+
+Since the learned features with original softmax loss may not be discriminative enough for open-set face recognition problem, several variants are proposed and can be formulated in a general form:
+
+$$
+\mathcal { L } = - G ( \boldsymbol { p } ( \boldsymbol { x } _ { i } ) ) \log \frac { e ^ { s T ( \cos \theta _ { y _ { i } } ) } } { e ^ { s T ( \cos \theta _ { y _ { i } } ) + \sum _ { j = 1 , j \neq y _ { i } } ^ { n } e ^ { s N ( t , \cos \theta _ { j } ) } } , }
+$$
+
+where $\begin{array} { r l r } { p ( x _ { i } ) } & { = } & { \frac { e ^ { s T ( \cos \theta _ { y _ { i } } ) } } { e ^ { s T ( \cos \theta _ { y _ { i } } ) + \sum _ { j = 1 , j \neq y _ { i } } ^ { n } e ^ { s N ( t , \cos \theta _ { j } ) } } } } \end{array}$ esN(t,cos θj) is the predicted ground truth probability and $G ( \boldsymbol { p } ( \boldsymbol { x } _ { i } ) )$ is an indicator function. $T ( \cos \theta _ { y _ { i } } )$ and $N ( t , \cos \theta _ { j } ) = I ( t , \cos \theta _ { j } ) \cos \theta _ { j } + c$ are the functions to modulate the positive and negative cosine similarities, respectively, where $c$ is a constant, and $I ( t , \cos \theta _ { j } )$ denotes the modulation coefficients of negative cosine similarities. In margin-based loss function, e.g, ArcFace, $G ( p ( x _ { i } ) ) = 1$ , $T ( \cos \theta _ { y _ { i } } ) = \cos ( \theta _ { y _ { i } } + m )$ , and $N ( t , \cos \theta _ { j } ) = \cos \theta _ { j }$ . It only modifies the positive cosine similarity of each sample to enhance the feature discrimination. As shown in Fig. 1, the modulation coefficients of each sample’ negative cosine similarity $I ( \cdot )$ is fixed as 1. The recent work, SV-Arc-Softmax emphasizes hard samples by increasing $I ( t , \cos \theta _ { j } )$ for hard samples. That is, $G ( p ( x _ { i } ) ) = 1$ and $N ( t , \mathrm { c o s } _ { \theta _ { j } } )$ is formulated as follows:
+
+$$
+N ( t , c o s _ { \theta _ { j } } ) = \left\{ \begin{array} { l l } { \cos \theta _ { j } , } & { T ( \cos \theta _ { y _ { i } } ) - \cos \theta _ { j } \geq 0 } \\ { t \cos \theta _ { j } + t - 1 , } & { T ( \cos \theta _ { y _ { i } } ) - \cos \theta _ { j } < 0 . } \end{array} \right.
+$$
+
+If a sample is defined to be easy, its negative cosine similarity is kept the same as the original one, $\cos \theta _ { j }$ ; if as a hard sample, its negative cosine similarity becomes $t \cos \theta _ { j } + t - 1$ . That is, as shown in Fig. 1, $I ( \cdot )$ is a constant and determined by a preset hyper-parameter $t$ . Meanwhile, since $t$ is always larger than 1, $t \cos \theta _ { j } + t - 1 > \cos \theta _ { j }$ always holds true, which means the model always focuses on hard samples, even in the early training stage. However, the parameter $t$ is sensitive that a large pre-defined value $( e . g . , > 1 . 4 ,$ ) may lead to convergence issue.
+
+# ADAPTIVE CURRICULAR LEARNING LOSS
+
+Next, we present the details of our proposed adaptive curriculum learning loss, which is the first attempt to introduce adaptive curriculum learning into deep face recognition. The formulation of our loss function is also contained in the general form, where $G ( p ( x _ { i } ) ) = 1$ , positive and negative cosine similarity functions are defined as follows:
+
+$$
+T ( \cos \theta _ { y _ { i } } ) = \cos ( \theta _ { y _ { i } } + m ) ,
+$$
+
+$$
+N ( t , \cos _ { \theta _ { j } } ) = \left\{ { \begin{array} { l l } { \cos \theta _ { j } , } & { T ( \cos \theta _ { y _ { i } } ) - \cos \theta _ { j } \geq 0 } \\ { \cos \theta _ { j } ( t + \cos \theta _ { j } ) , } & { T ( \cos \theta _ { y _ { i } } ) - \cos \theta _ { j } < 0 . } \end{array} } \right.
+$$
+
+It should be noted that the positive cosine similarity can adopt any margin-based loss functions and here we adopt ArcFace as the example. As shown in Fig. 1, the modulation coefficient of hard sample negative cosine similarity $I ( t , \bar { \theta _ { j } } )$ depends on both the value of $t$ and $\theta _ { j }$ . In the early training stage, learning from easy samples is beneficial to model convergence. Thus, $t$ should be close to zero and $I ( \cdot )$ is smaller than 1. Therefore, the weights of hard samples are reduced and the easy samples are emphasized relatively. As training goes on, the model gradually focuses on the hard samples, i.e., the value of $t$ shall increase and $I ( \cdot )$ is larger than 1. Then, the weights of hard samples are enlarged, which are thus emphasized. Moreover, within the same training stage, $I ( \cdot )$ is monotonically decreasing with $\theta _ { j }$ so that harder sample can be assigned with larger coefficient according to its difficultness. The value of the parameter $t$ is automatically estimated in our CurricularFace, otherwise it would require a lot of efforts for manually tuning.
+
+Adaptive estimation of $t$ It is critical to determine appropriate values of $t$ in different training stages. Ideally the value of $t$ can indicate the model training process. We empirically find the average of positive cosine similarities is a good indicator. However, mini-batch statistic-based methods usually face an issue: when many extreme data are sampled in one mini-batch, the statistics can be vastly noisy and the estimation will be unstable. Exponential Moving Average (EMA) is a common solution to address this issue (Li et al., 2019). Specifically, let $r ^ { ( k ) }$ be the average of the positive cosine similarities of the $k$ -th batch and be formulated as $\begin{array} { r } { r ^ { ( k ) } = \sum _ { i } \cos \theta _ { y _ { i } } } \end{array}$ , we have:
+
+$$
+t ^ { ( k ) } = \alpha r ^ { ( k ) } + ( 1 - \alpha ) t ^ { ( k - 1 ) } ,
+$$
+
+where $t ^ { 0 } = 0$ , $\alpha$ is the momentum parameter and set to 0.99. As shown in Fig. 2, the parameter $t$ increases with the model training, thus the gradient modulation coefficients’ range of hard sample, $M ( \cdot ) = 2 \cos \theta _ { j } + t$ , also increases. Therefore, hard samples are emphasized gradually. With the EMA, we avoid the hyper-parameter tuning and make the modulation coefficients of hard sample
+
+# Algorithm 1: CurricularFace
+
+Input: The deep feature of $_ { i }$ -th sample $x _ { i }$ with its corresponding label $y _ { i }$ , last fully-connected layer parameters $W$ , cosine similarity $\cos \theta _ { j }$ between two vectors, embedding network parameters $\Theta$ , learning rate $\lambda$ , number of iteration $k$ , parameter $t$ , and margin $m$   
+$k  0$ , $t \gets 0$ , $m \gets 0 . 5$ ;   
+while not converged do $k \gets k + 1$ ; if $\cos ( \theta _ { y _ { i } } + m ) > \cos \theta _ { j }$ then $N ( t , \cos \theta _ { j } ) = \cos \theta _ { j }$ ; else $\begin{array} { r l } { \small \int _ { - \infty } ( t , \cos \theta _ { j } ) = ( t ^ { ( k ) } + \cos \theta _ { j } ) \cos \theta _ { j } \ ; } \end{array}$ end $T ( \cos \theta _ { y _ { i } } ) = \cos ( \theta _ { y _ { i } } + m )$ ; Compute the loss $\mathcal { L }$ by Eq. 8; Compute the back-propagation error of $x _ { i }$ and $W _ { j }$ by Eq. 9; Update the parameters $W$ and $\Theta$ by: $\begin{array} { r } { \boldsymbol { W } ^ { ( k + 1 ) } = \boldsymbol { W } ^ { ( k ) } - \lambda ^ { ( k ) } \frac { \partial \boldsymbol { L } } { \partial \boldsymbol { W } } , \Theta ^ { ( k + 1 ) } = \Theta ^ { ( k ) } - \lambda ^ { ( k ) } \frac { \partial \boldsymbol { L } } { \partial x _ { i } } \frac { \partial x _ { i } } { \partial \Theta ^ { ( k ) } } ; } \end{array}$ Update the parameter $t$ by Eq. 7;
+
+negative cosine similarities $I ( \cdot )$ adaptive to the current training stage. To sum up, the loss function of our CurricularFace is formulated as follows:
+
+$$
+\mathcal { L } = - \log \frac { e ^ { s \cos ( \theta _ { y _ { i } } + m ) } } { e ^ { s \cos ( \theta _ { y _ { i } } + m ) } + \sum _ { j = 1 , j \neq y _ { i } } ^ { n } e ^ { s N ( t ^ { ( k ) } , \cos \theta _ { j } ) } } ,
+$$
+
+where $N ( t ^ { ( k ) } , \cos \theta _ { j } )$ is defined in Eq. 6. The entire training process is summarized in Algorithm 1.
+
+Fig. 3 illustrates how the loss changes from ArcFace to our CurricularFace during training. Here are some observations: 1) As we excepted, hard samples are suppressed in early training stage but emphasized later. 2) The ratio is monotonically increasing with $c o s \theta _ { j }$ , since the larger $c o s \theta _ { j }$ is, the harder the sample is. 3) The positive cosine similarity of a perceptualwell image is often large. However, during the early training stage, the negative cosine similarities of the perceptual-well image may also be large so that it could be classified as the hard one.
+
+Optimization Next, we show our CurricularFace can be easily optimized by the conventional stochastic gradient descent. Assuming $x _ { i }$ denotes the deep feature of $i$ -th sample which belongs to the $y _ { i }$ class, the input of the proposed function is the logit $f _ { j }$ , where $j$ denotes the $j$ -th class.
+
+![](images/f87305e9b5fbc1a980f008019d65e600689158bf54c829bba1922eba29835748.jpg)  
+Figure 2: Illustrations on the adaptive parameter $t$ (red line) and gradient modulation coefficients $M ( \cdot ) = 2 \cos \theta _ { j } + t$ of hard samples (green area). Since the number of mined hard samples reduces with the model training, the green area $M ( \cdot )$ is relatively smooth in early stage and there are some burrs in later stage.
+
+In the forwarding process, when $j ~ = ~ y _ { i }$ , it is the same as the ArcFace, i.e., $f _ { j } = s T ( \cos \theta _ { y _ { i } } )$ $T ( \cos \theta _ { y _ { i } } ) = \cos ( \theta _ { y _ { i } } + m )$ . When $j \neq y _ { i }$ , it has two cases, if $x _ { i }$ is an easy sample, it is the the same as the original softmax, i.e., $f _ { j } = s \cos \theta _ { j }$ . Otherwise, it will be modulated as $f _ { j } = s N ( t , \cos \theta _ { j } )$ , where $N ( t , \cos \theta _ { j } ) = ( t + \cos \theta _ { j } ) \cos \theta _ { j }$ . In the backward propagation process, the gradient of $x _ { i }$ and $W _ { j }$ can also be divided into three cases and formulated as follows:
+
+$$
+\frac { \partial L } { \partial x _ { i } } = \left\{ \begin{array} { l l } { \frac { \partial L } { \partial f _ { y _ { i } } } ( s \frac { \sin ( \theta _ { y _ { i } } + m ) } { \sin \theta _ { y _ { i } } } ) W _ { y _ { i } } , } & { j = y _ { i } } \\ { \frac { \partial L } { \partial f _ { j } } s W _ { j } , } & { j \neq y _ { i } , \mathrm { e a s y } , \frac { \partial L } { \partial W _ { j } } = \left\{ \begin{array} { l l } { \frac { \partial L } { \partial f _ { y _ { i } } } ( s \frac { \sin ( \theta _ { y _ { i } } + m ) } { \sin \theta _ { y _ { i } } } ) x _ { i } , } & { j = y _ { i } } \\ { \frac { \partial L } { \partial f _ { j } } s x _ { i } , } & { j \neq y _ { i } , \mathrm { e a s y } } \\ { \frac { \partial L } { \partial f _ { j } } s ( 2 \cos \theta _ { j } + t ) W _ { j } } & { j \neq y _ { i } , \mathrm { h a r d } } \end{array} \right. , } \end{array} \right.
+$$
+
+Based on the above formulations, we can find the gradient magnitude of the hard sample is determined by two parts, the negative cosine similarity $N ( \cdot )$ and the value of $t$ .
+
+![](images/6fdc953ddf73803d98dfe75a3455d0cdaea039f32fc11eb887efddabe900eb44.jpg)  
+Figure 3: Illustrations on (ratio between our loss and ArcFace, maximum $c o s \theta _ { j }$ ) from early (Top) to later (Bottom) training stages.
+
+Table 1: Decision boundaries of popular loss functions.   
+
+<table><tr><td rowspan=1 colspan=1>Loss</td><td rowspan=1 colspan=1>Decision Boundary</td></tr><tr><td rowspan=1 colspan=1>Softmax</td><td rowspan=1 colspan=1>cosOy=cos0j</td></tr><tr><td rowspan=1 colspan=1>SphereFace</td><td rowspan=1 colspan=1>cos(m0y）=cos0j</td></tr><tr><td rowspan=1 colspan=1>CosFace</td><td rowspan=1 colspan=1>cosθy-m=cos0j</td></tr><tr><td rowspan=1 colspan=1>ArcFace</td><td rowspan=1 colspan=1>cos(0y；+m)=cos0j</td></tr><tr><td rowspan=1 colspan=1>SV-Arc-Softmax</td><td rowspan=1 colspan=1>cos(0y+m)=cos0j(easy)cos(0y;+m)=tcos0j+t-i(hard)</td></tr><tr><td rowspan=1 colspan=1>CurricularFace (Ours)</td><td rowspan=1 colspan=1>cos(0yi+m)=cos0j (easy)cos(0y:+m)=(t+cos0j) cos0j(hard)</td></tr></table>
+
+Table 2: Verification performance of different values of $t$   
+
+<table><tr><td>Dataset (%)</td><td>t=0</td><td>t=0.3</td><td>t=0.7</td><td>t=1</td><td>Adaptive t</td></tr><tr><td>LFW</td><td>99.32</td><td>99.37</td><td>99.42</td><td>99.45</td><td>99.47</td></tr><tr><td>CFP-FP</td><td>95.90</td><td>96.47</td><td>96.66</td><td>93.94</td><td>96.96</td></tr></table>
+
+# DISCUSSIONS WITH SOTA LOSS FUNCTIONS
+
+Comparison with ArcFace and SV-Arc-Softmax We first discuss the difference between our CurricularFace and the two competitors, ArcFace and SV-Arc-Softmax, from the perspective of the decision boundary in Tab. 1. ArcFace introduces a margin function $T ( \cos \theta _ { y _ { i } } ) \dot { ~ = ~ } \dot { \cos ( \theta _ { y _ { i } } + m ) }$ from the perspective of positive cosine similarity. As shown in Fig. 4, its decision condition changes from $\cos \theta _ { y _ { i } } = \cos \theta _ { j }$ (i.e., blue line) to $\cos ( \dot { \theta } _ { y _ { i } } + m ) = \cos \bar { \theta } _ { j }$ (i.e., red line) for each sample. SV-Arc-Softmax introduces additional margin from the perspective of negative cosine similarity for hard samples, and the decision boundary becomes $\cos ( \theta _ { y _ { i } } + m ) = t \cos \theta _ { j } + t - 1$ (i.e., green line). Conversely, we adaptively adjust the weights of hard samples in different training stages. The decision condition becomes $\cos ( \theta _ { y _ { i } } + m ) = ( t + \cos \theta _ { j } ) \cos \theta _ { j }$ (i.e., purple line). During the training stage, the decision boundary for hard samples changes from one purple line (early stage) to another (later stage), which emphasizes easy samples first and hard samples later.
+
+Comparison with Focal loss Focal loss is a soft mining-based loss, which is formulated as: $G ( \bar { p ( x ) } ) = \alpha ( 1 - p ( x _ { i } ) ) ^ { \beta }$ , where $\alpha$ and $\beta$ are modulating factors that need to be tuned manually. The definition of hard samples in Focal loss is ambiguous, since it always focuses on relatively hard samples by reducing the weight of easier samples during the entire training process. In contrast, the definition of hard samples in our CurricularFace is more clear, i.e., mis-classified samples. Meanwhile, the weights of hard samples are adaptively determined in different training stages.
+
+# EXPERIMENTS
+
+# IMPLEMENTATION DETAILS
+
+Datasets We separately employ CASIA-WebFace (Yi et al., 2014) and refined MS1MV2 (Deng et al., 2019) as our training data for fair comparisons with other methods. We extensively test our method on several popular benchmarks, including LFW (Huang et al., 2007), CFP-FP (Sengupta et al., 2016), CPLFW (Zheng et al., 2018), AgeDB (Moschoglou et al., 2017), CALFW (Zheng et al., 2017), IJB-B (Whitelam et al., 2017), IJB-C (Maze et al., 2018), and MegaFace (KemelmacherShlizerman et al., 2016).
+
+Training Setting We follow Deng et al. (2019) to generate the normalised faces $( 1 1 2 \times 1 1 2 )$ with five landmarks (Zhang et al., 2016). For the embedding network, we adopt ResNet50 and ResNet100 as in Deng et al. (2019). Our framework is implemented in Pytorch (Paszke et al., 2017). We train models on 4 NVIDIA Tesla P40 (24GB) GPU with batch size 512. The models are trained with SGD algorithm, with momentum 0.9 and weight decay $5 e - 4$ . On CASIA-WebFace, the learning rate starts from 0.1 and is divided by 10 at 28, 38, 46 epochs. The training process is finished at 50 epochs. On MS1MV2, we divide the learning rate at 10, 18, 22 epochs and finish at 24 epochs. We follow the common setting as Deng et al. (2019) to set scale $s = 6 4$ and margin $m = 0 . 5$ , respectively. Last but not least, since we only modify the loss function but use the same backbone as previous methods (e.g., ArcFace), NO additional time complexity is introduced for inference.
+
+![](images/86c3df2d7b59ac8a5f55c0d97984177013a5da36e1db12403de19ad2a54b37ce.jpg)  
+Figure 4: From left to right, decision boundaries of ArcFace, SV-Arc-Softmax, and ours. Blue line, red line, green line and purple line denote the decision boundary of Softmax, ArcFace, SV-Arc-Softmax, and ours, respectively. $m$ denotes the angular margin added by ArcFace. $d$ denotes the additional margin of SVArc-Softmax and ours. In SV-Arc-Softmax, $d = ( t - 1 ) \cos \theta _ { j } +$ $t - 1$ . In ours, $d = ( t + \cos \theta _ { j } - 1 ) \cos \theta _ { j }$ .
+
+Table 3: Verification performance of different strategies for setting t.
+
+![](images/9afdd5c6df3e867859846790a9f8b63d321161a6b48085b8dba8a391ec959dc7.jpg)  
+Figure 5: Illustration on convergence issue with small backbone.
+
+# ABLATION STUDY
+
+Effects on Fixed vs. Adaptive Parameter $t$ We first investigate the effect of adaptive estimation of $t$ . We choose four fixed values between 0 and 1 for comparison. Specifically, 0 means the modulation coefficient $I ( \cdot )$ of each hard sample’s negative cosine similarity is always reduced based on its difficultness. In contrast, 1 means the hard samples are always emphasized. 0.3 and 0.7 are between the two cases. Tab. 2 shows that it is more effective to learn from easier samples first and hard samples later based on our adaptively estimated parameter $t$ .
+
+Effects on Different Statistics for Estimating $t$ We now investigate the effects of several other statistics, i.e., mode of positive cosine similarities in a mini-batch, or mean of the predicted ground truth probability for estimating $t$ in our loss. As Tab. 3 shows, on one hand, the mean of positive cosine similarities is better than the mode. On the other hand, the positive cosine similarity is more accurate than the predicted ground truth probability to indicate the training stages.
+
+Robustness on Training Convergence As claimed in Li (2019), ArcFace exists divergence issue when using small backbones like MobileFaceNet. As the result, softmax loss must be incorporated for pre-training. To illustrate the robustness of our loss function on convergence issue with small backbone, we use the MobileFaceNet as the network architecture and train it on CASIA-WebFace. As shown in Fig. 5, when the margin $m$ is set to 0.5, the model trained with our loss achieves 99.25 accuracy on LFW, while the model trained with ArcFace does not converge and the loss is NAN at about 2, 400-th step. When the margin $m$ is set to 0.45, both losses can converge, but our loss achieves better performance $( 9 9 . 2 0 \%$ vs. $9 9 . 1 0 \%$ ). Comparing the yellow and red curves, since the losses of hard samples are reduced in early training stages, our loss converges much faster in the beginning, leading to lower loss than ArcFace. Later on, the value of our loss is slightly larger than ArcFace, because we emphasize the hard samples in later stages. The results prove that learning from easy samples first and hard samples later is beneficial to model convergence.
+
+# COMPARISONS WITH SOTA METHODS
+
+Results on LFW, CFP-FP, CPLFW, AgeDB and CALFW Next, we train our CurricularFace on dataset MS1MV2 with ResNet100, and compare with the SOTA competitors on various benchmarks, including LFW for unconstrained face verification, CFP-FP and CPLFW for large pose variations, AgeDB and CALFW for age variations. As reported in Tab. 4, our CurricularFace achieves comparable result (i.e., $9 9 . 8 0 \%$ ) with the competitors on LFW where the performance is near saturated. While for both CFP-FP and CPLFW, our method shows superiority over the baselines including general methods, e.g., (Wen et al., 2016), (Cao et al., 2018b), and cross-pose methods, e.g., (Tran et al., 2017), (Peng et al., 2017), (Cao et al., 2018a) and (Deng et al., 2018). As a recent face recognition method, SV-Arc-Softmax achieves better performance than ArcFace, but still worse than Our CurricularFace. Finally, for AgeDB and CALFW, as Tab. 4 shows, our CurricularFace again achieves the best performance than all of the other state-of-the-art methods.
+
+Table 4: Verification comparison with SOTA methods on various small-scale benchmarks.   
+
+<table><tr><td>Methods (%)</td><td>LFW</td><td>CFP-FP</td><td>CPLFW</td><td>AgeDB</td><td>CALFW</td></tr><tr><td>Center Loss (ECCV&#x27;16)</td><td>98.75</td><td>1</td><td>77.48</td><td>1</td><td>85.48</td></tr><tr><td>SphereFace (CVPR&#x27;17)</td><td>99.27</td><td>一</td><td>81.40</td><td></td><td>90.30</td></tr><tr><td>DRGAN (CVPR&#x27;17)</td><td>1</td><td>93.41</td><td>1</td><td></td><td>1</td></tr><tr><td>Peng et al. (ICCV&#x27;17)</td><td>一</td><td>93.76</td><td>一</td><td></td><td>一</td></tr><tr><td>VGGFace2 (FG&#x27;18)</td><td>99.43</td><td>一</td><td>84.00</td><td></td><td>90.57</td></tr><tr><td>Dream (CVPR&#x27;18)</td><td>1</td><td>93.98</td><td>一</td><td></td><td>一</td></tr><tr><td>Deng et al.(CVPR&#x27;18)</td><td>99.60</td><td>94.05</td><td></td><td></td><td></td></tr><tr><td>ArcFace (CVPR&#x27;19)</td><td>99.77</td><td>98.27</td><td>92.08</td><td>98.15</td><td>95.45</td></tr><tr><td>SV-Arc-Softmax</td><td>99.78</td><td>98.28</td><td>92.83</td><td>97.95</td><td>96.10</td></tr><tr><td>CurricularFace (Ours)</td><td>99.80</td><td>98.37</td><td>93.13</td><td>98.32</td><td>96.20</td></tr></table>
+
+Table 5: 1:1 verification TAR ( ${ \bf @  F A R = }$ 1e − 4) on IJB-B and IJB-C.   
+
+<table><tr><td>Methods (%)</td><td>IJB-B</td><td>IJB-C</td></tr><tr><td>SENet50 (FG&#x27;18)</td><td>80.0</td><td>84.1</td></tr><tr><td>Multicolumn (BMVC&#x27;18)</td><td>83.1</td><td>86.2</td></tr><tr><td>DCN (ECCV&#x27;18)</td><td>84.9</td><td>88.5</td></tr><tr><td>ArcFace-R100 (CVPR&#x27;19)</td><td>94.2</td><td>95.6</td></tr><tr><td>Adacos (CVPR&#x27;19)</td><td>1</td><td>92.4</td></tr><tr><td>P2SGrad (CVPR&#x27;19)</td><td>1</td><td>92.3</td></tr><tr><td>PFE (ICCV&#x27;19)</td><td>一</td><td>93.3</td></tr><tr><td>SV-Arc-Softmax</td><td>93.6</td><td>95.2</td></tr><tr><td>CurricularFace (Ours)</td><td>94.8</td><td>96.1</td></tr></table>
+
+Table 6: Verification comparison with SOTA methods on MegaFace Challenge 1 using FaceScrub as the probe set. Left table: ‘Id’ refers to the rank-1 face identification accuracy with 1M distractors, and ‘Ver’ refers to the face verification TAR at $1 0 ^ { - 6 }$ FAR. ‘R’ refers to data refinement on both probe set and 1M distractors. Right figure: Rank-1 identification results of recent SOTA methods on probe set refined from ArcFace.   
+
+<table><tr><td>CASIA(%)</td><td>Id</td><td>Ver</td><td>MS1MV2(%)</td><td>Id</td><td>Ver</td><td>CosFace(CVPR’18)- 97.91</td><td></td></tr><tr><td>Contrastive Loss (CVPR&#x27;14)</td><td>65.21</td><td>78.86</td><td>CosFace-MS1MV2-R100</td><td>80.56</td><td>96.56</td><td></td><td></td></tr><tr><td>Triplet (CVPR&#x27;15)</td><td>64.79</td><td>78.32</td><td>CosFace-MS1MV2-R100, R</td><td>97.91</td><td>97.91</td><td></td><td>Adacos (CVPR&#x27;19)-97.41</td></tr><tr><td>Center Loss (ECCV&#x27;16)</td><td>65.49</td><td>80.14</td><td>ArcFace-MS1MV2-R100</td><td>81.03</td><td>96.98</td><td></td><td></td></tr><tr><td>SphereFace(CVPR&#x27;17)</td><td>72.73</td><td>85.56</td><td>ArcFace-MS1MV2-R100, R</td><td>98.35</td><td>98.48</td><td></td><td>P2SGrad (CVPR’19)-97.25</td></tr><tr><td>CosFace (CVRP&#x27;18)</td><td>77.11</td><td>89.88</td><td>PFE (ICCV&#x27;19)</td><td>78.95</td><td>92.51</td><td></td><td>AreFace (CVPR&#x27;19)-98.35</td></tr><tr><td>AM-Softmax (SPL&#x27;18)</td><td>72.47</td><td>84.44</td><td>Adacos,R(CVPR&#x27;19&#x27;)</td><td>97.41</td><td></td><td></td><td></td></tr><tr><td>ArcFace-CASIA-R50 (CVPR&#x27;19)</td><td>77.50</td><td>92.34</td><td>P2SGrad,R(CVPR&#x27;19&#x27;)</td><td>97.25</td><td></td><td></td><td>SV-Arc-Softmax (arXiv&#x27;19)- 97.14</td></tr><tr><td>ArcFace-CASIA-R50, R</td><td>91.75</td><td>93.69</td><td>SV-Arc-Softmax,R</td><td>97.14</td><td>97.57</td><td></td><td></td></tr><tr><td>Ours-CASIA-R50</td><td>77.65</td><td>92.91</td><td>Ours-MS1MV2-R100</td><td>81.26</td><td>97.26</td><td></td><td>CurricularFace (Ours)-98.71</td></tr><tr><td>Ours-CASIA-R50, R</td><td>92.48</td><td>94.55</td><td>Ours-MS1MV2-R100, R</td><td>98.71</td><td>98.64</td><td>97</td><td></td></tr></table>
+
+Results on IJB-B and IJB-C The IJB-B dataset contains 1, 845 subjects with 21.8K still images and 55K frames from 7, 011 videos. In the 1:1 verification, there are 10, 270 positive matches and 8M negative matches. The IJB-C dataset is a further extension of IJB-B, which contains about 3, 500 identities with a total of 31, 334 images and 117, 542 unconstrained video frames. In the 1:1 verification, there are 19, 557 positive matches and 15, 638, 932 negative matches. On IJB-B and IJB-C datasets, we employ MS1MV2 and the ResNet100 for a fair comparison with recent methods. We follow the testing protocol in ArcFace and take the average of the image features as the corresponding template representation without bells and whistles. Tab. 5 exhibits the performance of different methods, e.g., Multicolumn (Xie & Zisserman, 2018), DCN (Xie et al., 2018), Adacos (Zhang et al., 2019a), P2SGrad (Zhang et al., 2019b), PFE (Shi et al., 2019) and SV-Arc-Softmax (Wang et al., 2018b) on IJB-B and IJB-C 1:1 verification, our method again achieves the best performance.
+
+Results on MegaFace Finally, we evaluate the performance on the MegaFace Challenge. The gallery set of MegaFace includes 1M images of 690K subjects, and the probe set includes 100K photos of 530 unique individuals from FaceScrub. We report the two testing results under two protocols (large or small training set). Here, we use CASIA-WebFace and MS1MV2 under the small protocol and large protocol, respectively. In Tab. 6, our method achieves the best singlemodel identification and verification performance under both protocols, surpassing the recent strong competitors, e.g., CosFace, ArcFace, Adacos, P2SGrad and PFE. We also report the results following the ArcFace testing protocol, which refines both the probe set and the gallery set. As shown from the figure in Tab. 6, our method still clearly outperforms the competitors and achieves the best performance on both verification and identification.
+
+# CONCLUSIONS
+
+In this paper, we propose a novel Adaptive Curriculum Learning Loss that embeds the idea of adaptive curriculum learning into deep face recognition. Our key idea is to address easy samples in the early training stage and hard ones in the later stage. Our method is easy to implement and robust to converge. Extensive experiments on popular facial benchmarks demonstrate the effectiveness of our method compared to the state-of-the-art competitors. Following the main idea of this work, future research can be expanded in various aspects, including designing a better function $N ( \cdot )$ for negative cosine similarity that shares similar adaptive characteristic during training, and investigating the effects of noise samples that could be optimized as hard samples.
+
+# REFERENCES
+
+Sumit Basu and Janara Christensen. Teaching classification boundaries to humans. In AAAI, 2013.
+
+Yoshua Bengio, Jer´ ome Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In ˆ ICML, 2009.
+
+Kaidi Cao, Yu Rong, Cheng Li, Xiaoou Tang, and Chen Change Loy. Pose-robust face recognition via deep residual equivariant mapping. In CVPR, 2018a.
+
+Qiong Cao, Li Shen, Weidi Xie, Omkar M. Parkhi, and Andrew Zisserman. Vggface2: A dataset for recognising faces across pose and age. In FG, 2018b.
+
+Beidi Chen, Weiyang Liu, Animesh Garg, Zhiding Yu, Anshumali Shrivastava, and Anima Anandkumar. Angular visual hardness. In ICML Workshop on Deep Phenomena, 2019.
+
+Sheng Chen, Yang Liu, Xiang Gao, and Zhen Han. Mobilefacenets: Efficient cnns for accurate real-time face verification on mobile devices. In CCBR, 2018.
+
+Jiankang Deng, Shiyang Cheng, Niannan Xue, Yuxiang Zhou, and Stefanos Zafeiriou. Uv-gan: Adversarial facial uv map completion for pose-invariant face recognition. In CVPR, 2018.
+
+Jiankang Deng, Jia Guo, and Stefanos Zafeiriou. ArcFace: Additive angular margin loss for deep face recognition. In CVPR, 2019.
+
+Gary B. Huang, Manu Ramesh, Tamara Berg, and Erik Learned-Miller. Labeled faces in the wild: A database for studying face recognition in unconstrained environments. Technical Report 07-49, University of Massachusetts, Amherst, October 2007.
+
+Ira Kemelmacher-Shlizerman, Steven M Seitz, Daniel Miller, and Evan Brossard. The megaface benchmark: 1 million faces for recognition at scale. In CVPR, 2016.
+
+M Pawan Kumar, Benjamin Packer, and Daphne Koller. Self-paced learning for latent variable models. In NIPS, 2010.
+
+Buyu Li, Yu Liu, and Xiaogang Wang. Gradient harmonized single-stage detector. In AAAI, 2019.
+
+Weiyang Li, Yandong Wen, Zhiding Yu, Ming Li, Bhiksha Raj, and Le Song. Sphereface: Deep hypersphere embedding for face recognition. In CVPR, 2017.
+
+Xianyang Li. Airface: Lightweight and efficient model for face recognition. arXiv:1907.12256, 2019.
+
+Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense object ´ detection. In ICCV, pp. 2980–2988, 2017.
+
+Weiyang Liu, Yandong Wen, Zhiding Yu, and Meng Yang. Large-margin softmax loss for convolutional neural networks. In ICML, 2016.
+
+Brianna Maze, Jocelyn Adams, James A Duncan, Nathan Kalka, Tim Miller, Charles Otto, Anil K Jain, W Tyler Niggel, Janet Anderson, Jordan Cheney, et al. Iarpa janus benchmark-c: Face dataset and protocol. In ICB, 2018.
+
+Stylianos Moschoglou, Athanasios Papaioannou, Christos Sagonas, Jiankang Deng, Irene Kotsia, and Stefanos Zafeiriou. Agedb: the first manually collected, in-the-wild age database. In CVPR Workshops, 2017.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in PyTorch. In NIPS Autodiff Workshop, 2017.
+
+Xi Peng, Xiang Yu, Kihyuk Sohn, Dimitris Metaxas, and Manmohan Chandraker. Reconstructionbased disentanglement for poseinvariant face recognition. In ICCV, 2017.
+
+Florian Schroff, Dmitry Kalenichenko, and James Philbin. Facenet: A unified embedding for face recognition and clustering. In CVPR, 2015.
+
+S. Sengupta, J.-C. Chen, C. Castillo, V. M. Patel, R. Chellappa, and D.W. Jacobs. Frontal to profile face verification in the wild. In WACV, 2016.
+
+Yichun Shi, Anil K Jain, and Nathan D Kalka. Probabilistic face embeddings. In ICCV, 2019.
+
+Abhinav Shrivastava, Abhinav Gupta, and Ross Girshick. Training region-based object detectors with online hard example mining. In CVPR, 2016.
+
+Luan Tran, Xi Yin, and Xiaoming Liu. Disentangled representation learning GAN for pose-invariant face recognition. In CVPR, 2017.
+
+Hao Wang, Yitong Wang, Zheng Zhou, Xing Ji, Dihong Gong, Jingchao Zhou, Zhifeng Li, and Wei Liu. Cosface: Large margin cosine loss for deep face recognition. In CVPR, 2018a.
+
+Xiaobo Wang, Shuo Wang, Shifeng Zhang, Tianyu Fu, Hailin Shi, and Tao Mei. Support vector guided softmax loss for face recognition. arXiv:1812.11317, 2018b.
+
+Yandong Wen, Kaipeng Zhang, Zhifeng Li, and Yu Qiao. A discriminative feature learning approach for deep face recognition. In ECCV, 2016.
+
+Cameron Whitelam, Emma Taborsky, Austin Blanton, Brianna Maze, Jocelyn Adams, Tim Miller, Nathan Kalka, Anil K Jain, James A Duncan, Kristen Allen, et al. Iarpa janus benchmark-b face dataset. In CVPR Workshops, 2017.
+
+Weidi Xie and Andrew Zisserman. Multicolumn networks for face recognition. In BMVC, 2018.
+
+Weidi Xie, Li Shen, and Andrew Zisserman. Comparator networks. In ECCV, 2018.
+
+Dong Yi, Zhen Lei, Shengcai Liao, and Stan Z. Li. Learning face representation from scratch. arXiv:1411.7923, 2014.
+
+Kaipeng Zhang, Zhanpeng Zhang, Zhifeng Li, and Yu Qiao. Joint face detection and alignment using multitask cascaded convolutional networks. IEEE Signal Processing Letters, 23(10):1499–1503, 2016.
+
+Xiao Zhang, Rui Zhao, Yu Qiao, Xiaogang Wang, and Hongsheng Li. Adacos: Adaptively scaling cosine logits for effectively learning deep face representations. In CVPR, 2019a.
+
+Xiao Zhang, Rui Zhao, Junjie Yan, Mengya Gao, Yu Qiao, Xiaogang Wang, and Hongsheng Li. P2sgrad: Refined gradients for optimizing deep face models. In CVPR, 2019b.
+
+Tianyue Zheng, Weihong Deng, and Jiani Hu. Cross-age lfw: A database for studying cross-age face recognition in unconstrained environments. arXiv:1708.08197, 2017.
+
+Tianyue Zheng, Weihong Deng, and Jiani Hu. Cross-pose lfw: A database for studying cross-pose face recognition in unconstrained environments. Technical Report 18-01, Beijing University of Posts and Telecommunications, February 2018.
+
+Tianyi Zhou and Jeff Bilmes. Minimax curriculum learning: Machine teaching with desirable difficulties and scheduled diversity. In ICLR, 2018. URL https://openreview.net/forum? id $=$ BywyFQlAW.

parse/train/B1eksh4KvH/B1eksh4KvH_content_list.json

@@ -0,0 +1,1320 @@
+[
+    {
+        "type": "text",
+        "text": "CURRICULARFACE: ADAPTIVE CURRICULUM LEARN-ING LOSS FOR DEEP FACE RECOGNITION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As an emerging topic in face recognition, designing margin-based loss functions can increase the feature margin between different classes for enhanced discriminability. More recently, absorbing the idea of mining-based strategies is adopted to emphasize the misclassified samples and achieve promising results. However, during the entire training process, the prior methods either do not explicitly emphasize the sample based on its importance that renders the hard samples not fully exploited; or explicitly emphasize the effects of semi-hard/hard samples even at the early training stage that may lead to convergence issue. In this work, we propose a novel Adaptive Curriculum Learning loss (CurricularFace) that embeds the idea of curriculum learning into the loss function to achieve a novel training strategy for deep face recognition, which mainly addresses easy samples in the early training stage and hard ones in the later stage. Specifically, our CurricularFace adaptively adjusts the relative importance of easy and hard samples during different training stages. In each stage, different samples are assigned with different importance according to their corresponding difficultness. Extensive experimental results on popular benchmarks demonstrate the superiority of our CurricularFace over the state-of-the-art competitors. Code will be available upon publication. ",
+        "bbox": [
+            233,
+            265,
+            764,
+            501
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            523,
+            305,
+            540
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The success of Convolutional Neural Networks (CNNs) on face recognition can be mainly credited to : enormous training data, network architectures, and loss functions. Recently, designing appropriate loss functions that enhance discriminative power is pivotal for training deep face CNNs. ",
+        "bbox": [
+            176,
+            554,
+            821,
+            597
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Current state-of-the-art face recognition methods mainly adopt softmax-based classification loss. Since the learned features with the original softmax is not discriminative enough for the open-set face recognition problem, several margin-based variants have been proposed to enhance features’ discriminative power. For example, explicit margin, i.e., CosFace (Wang et al., 2018a), Sphereface (Li et al., 2017), ArcFace (Deng et al., 2019), and implicit margin, i.e., Adacos (Zhang et al., 2019a), supplement the original softmax function to enforce greater intra-class compactness and inter-class discrepancy, which are shown to result in more discriminate features. However, these margin-based loss functions do not explicitly emphasize each sample according to its importance. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            715
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As demonstrated in Chen et al. (2019), hard sample mining is also a critical step to further improve the final accuracy. Recently, Triplet loss (Schroff et al., 2015) and SV-Arc-Softmax (Wang et al., 2018b) integrate the motivations of both margin and mining into one framework for deep face recognition. Triplet loss adopts a semi-hard mining strategy to obtain semi-hard triplets and enlarge the margin between triplet samples. SV-Arc-Softmax (Wang et al., 2018b) clearly defines hard samples as misclassified samples and emphasizes them by increasing the weights of their negative cosine similarities with a preset constant. In a nutshell, mining-based loss functions explicitly emphasize the effects of semi-hard or hard samples. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, there are drawbacks in training strategies of both margin- and mining-based loss functions. For margin-based methods, mining strategy is ignored and thus the difficultness of each sample is not fully exploited, which may lead to convergence issues when using a large margin on small backbones, e.g., MobileFaceNet (Chen et al., 2018). As shown in Fig. 1, the modulation coefficient for the negative cosine similarities $I ( \\cdot )$ is fixed as a constant 1 in ArcFace for all samples during the entire training process. For mining-based methods, over-emphasizing hard samples in early training stage may hinder the model to converge. As SV-Arc-Softmax claimed, the manually defined constant $t$ plays a key role in the model convergence property and a slight larger value (e.g., ${ > } 1 . 4$ ) may cause the model difficult to converge. Thus $t$ needs to be carefully tuned. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/26d2e0767b65dd67f07c9b1c61156c4365d57d1148bf6246b32fab974d2aa629.jpg",
+        "image_caption": [
+            "Figure 1: Different training strategies for modulating negative cosine similarities of hard samples (i.e., the mis-classified sample) in ArcFace, SV-Arc-Softmax and our CurricularFace. Left: The modulation coefficients $I ( t , \\cos \\theta _ { j } )$ for negative cosine similarities of hard samples in different methods, where $t$ is an adaptively estimated parameter and $\\theta _ { j }$ denotes the angle between the hard sample and the non-ground truth $j$ -class center. Right: The corresponding hard samples’ negative cosine similarities $N ( t , \\cos \\theta _ { j } ) = I ( t , \\cos \\theta _ { j } ) \\cos \\theta _ { j } + c$ after modulation, where $c$ indicates a constant. On one hand, during early training stage (e.g., $t$ is close to 0), hard sample’s negative cosine similarities is usually reduced and thus leads to smaller hard sample loss than the original one. Therefore, easier samples are relatively emphasized; during later training stage (e.g., $t$ is close to 1), the hard sample’s negative cosine similarities are enhanced and thus leads to larger hard sample loss. On the other hand, in the same training stage, we modulate the hard samples’ negative cosine similarities with $\\cos \\theta _ { j }$ . Specifically, the smaller the angle $\\theta _ { j }$ is, the larger the modulation coefficient should be. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            99,
+            785,
+            286
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            458,
+            825,
+            501
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose a novel adaptive curriculum learning loss, termed CurricularFace, to achieve a novel training strategy for deep face recognition. Motivated by the nature of human learning that easy cases are learned first and then come the hard ones (Bengio et al., 2009), our CurricularFace incorporates the idea of Curriculum Learning (CL) into face recognition in an adaptive manner, which differs from the traditional CL in two aspects. First, the curriculum construction is adaptive. In traditional CL, the samples are ordered by the corresponding difficultness, which are often defined by a prior and then fixed to establish the curriculum. In CurricularFace, the samples are randomly selected in each mini-batch, while the curriculum is established adaptively via mining the hard samples online, which shows the diversity in samples with different importance. Second, the importance of hard samples are adaptive. On one hand, the relative importance between easy and hard samples is dynamic and could be adjusted in different training stages. On the other hand, the importance of each hard sample in current mini-batch depends on its own difficultness. ",
+        "bbox": [
+            173,
+            507,
+            825,
+            674
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Specifically, the mis-classified samples in mini-batch are chosen as hard samples and weighted by adjusting the modulation coefficients $I ( t , c o s \\theta _ { j } )$ of cosine similarities between the sample and the non-ground truth class center vectors, i.e., negative cosine similarity $N ( t , c o s \\theta _ { j } )$ . To achieve the goal of adaptive curricular learning in the entire training, we design a novel coefficient function $I ( \\cdot )$ that is determined by two factors: 1) the adaptively estimated parameter $t$ that utilizes moving average of positive cosine similarities between samples and the corresponding ground-truth class center to unleash the burden of manually tuning; and 2) the angle $\\theta _ { j }$ that defines the difficultness of hard samples to achieve adaptive assignment. To sum up, the contributions of this work are: ",
+        "bbox": [
+            174,
+            681,
+            825,
+            792
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose an adaptive curriculum learning loss for face recognition, which automatically emphasizes easy samples first and hard samples later. To the best of our knowledge, it is the first work to introduce the idea of adaptive curriculum learning for face recognition. We design a novel modulation coefficient function $I ( \\cdot )$ to achieve adaptive curriculum learning during training, which connects positive and negative cosine similarity simultaneously without the need of manually tuning any additional hyper-parameter. • We conduct extensive experiments on popular facial benchmarks, which demonstrate the superiority of our CurricularFace over the state-of-the-art competitors. ",
+        "bbox": [
+            215,
+            804,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            313,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Margin-based loss function Loss design is pivotal for large-scale face recognition. Current stateof-the-art deep face recognition methods mostly adopt softmax-based classification loss. Since the learned features with the original softmax loss are not guaranteed to be discriminative enough for open-set face recognition problem, margin-based losses (Liu et al., 2016; Li et al., 2017; Deng et al., 2019) are proposed. Though the margin-based loss functions are verified to obtain good performance, they do not take the difficultness of each sample into consideration, while our CurricularFace emphasizes easy samples first and hard samples later, which is more reasonable and effectiveness. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Mining-based loss function Though some mining-based loss function such as Focal loss (Lin et al., 2017), Online Hard Sample Mining (OHEM) (Shrivastava et al., 2016) are prevalent in the field of object detection, they are rarely used in face recognition. OHEM focuses on the large-loss samples in one mini-batch, in which the percentage of the hard samples is empirically determined and easy samples are completely discarded. Focal loss is a soft mining variant that rectifies the loss function to an elaborately designed form, where two hyper-parameters should be tuned with a lot of efforts to decide the weights of each samples and hard samples are emphasized by reducing the weight of easy samples. The recent work, SV-Arc-Softmax (Wang et al., 2018b) fuses the motivations of both margin and mining into one framework for deep face recognition. They define hard samples as misclassified samples and enlarge the weight of hard samples with a preset constant. Our method differs from SV-Arc-Softmax in three aspects: 1) We do not always emphasize the hard samples, especially in the early training stages. 2) We assign different weights for hard samples according to their corresponding difficultness. 3) There’s no need in our method to manually tune the additional hyper-parameter $t$ , which is estimated adaptively. ",
+        "bbox": [
+            173,
+            244,
+            825,
+            439
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Curriculum Learning Learning from easier samples first and harder samples later is a common strategy in Curriculum Learning (CL) (Bengio et al., 2009), (Zhou & Bilmes, 2018). The key problem in CL is to define the difficultness of each sample. For example, Basu & Christensen (2013) takes the negative distance to the boundary as the indicator for easiness in classification. However, the ad-hoc curriculum design in CL turns out to be difficult to implement in different problems. To alleviate this issue, Kumar et al. (2010) designs a new formulation, called Self-Paced Learning (SPL), where examples with lower losses are considered to be easier and emphasized during training. The key differences between our CurricularFace with SPL are: 1) Our method focuses on easier samples in the early training stage and emphasizes hard samples in the later training stage. 2) Our method proposes a novel modulation function $N ( \\cdot )$ for negative cosine similarities, which achieves not only adaptive assignment on modulation coefficients $I ( \\cdot )$ for different samples in the same training stage, but also adaptive curriculum learning strategy in different training stages. ",
+        "bbox": [
+            173,
+            454,
+            825,
+            619
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "THE PROPOSED CURRICULARFACE",
+        "text_level": 1,
+        "bbox": [
+            176,
+            640,
+            467,
+            656
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "PRELIMINARY KNOWLEDGE ON LOSS FUNCTION ",
+        "bbox": [
+            174,
+            670,
+            514,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The original softmax loss is formulated as follows: ",
+        "bbox": [
+            174,
+            695,
+            508,
+            710
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/49041f0655cf17db1b850f6d507f2ed690390a769d50fea0a658183d67f58914.jpg",
+        "text": "$$\n\\mathcal { L } = - \\log \\frac { e ^ { W _ { y _ { i } } x _ { i } + b _ { y _ { i } } } } { \\sum _ { j = 1 } ^ { n } e ^ { W _ { j } x _ { i } + b _ { j } } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            712,
+            584,
+            747
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $x _ { i } \\in R ^ { d }$ denotes the deep feature of $i$ -th sample which belongs to the $y _ { i }$ class, $W _ { j } \\in R ^ { d }$ denotes the $j$ -th column of the weight $W \\in R ^ { d \\times n }$ and $b _ { j }$ is the bias term. The class number and the embedding feature size are $n$ and $d$ , respectively. In practice, the bias is usually set to $b _ { j } = 0$ and the individual weight is set to $| | W _ { j } | | = 1$ by $l _ { 2 }$ normalization. The deep feature is also normalized and re-scaled to $s$ . Thus, the original softmax can be modified as follows: ",
+        "bbox": [
+            173,
+            750,
+            825,
+            821
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/db549a9a49cf6dbfde8c591a7b12f8073d43a0c944258578617c1479d1d61b00.jpg",
+        "text": "$$\n\\mathcal { L } = - \\log \\frac { e ^ { s ( \\cos \\theta _ { y _ { i } } ) } } { e ^ { s ( \\cos \\theta _ { y _ { i } } ) } + \\sum _ { j = 1 , j \\neq y _ { i } } ^ { n } e ^ { s ( \\cos \\theta _ { j } ) } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            823,
+            638,
+            859
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Since the learned features with original softmax loss may not be discriminative enough for open-set face recognition problem, several variants are proposed and can be formulated in a general form: ",
+        "bbox": [
+            174,
+            861,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a80aaadc742bfe2e852b39f270e9f0c992a7c6071ad7e82711b580a7dadaaca0.jpg",
+        "text": "$$\n\\mathcal { L } = - G ( \\boldsymbol { p } ( \\boldsymbol { x } _ { i } ) ) \\log \\frac { e ^ { s T ( \\cos \\theta _ { y _ { i } } ) } } { e ^ { s T ( \\cos \\theta _ { y _ { i } } ) + \\sum _ { j = 1 , j \\neq y _ { i } } ^ { n } e ^ { s N ( t , \\cos \\theta _ { j } ) } } , }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            890,
+            668,
+            928
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r l r } { p ( x _ { i } ) } & { = } & { \\frac { e ^ { s T ( \\cos \\theta _ { y _ { i } } ) } } { e ^ { s T ( \\cos \\theta _ { y _ { i } } ) + \\sum _ { j = 1 , j \\neq y _ { i } } ^ { n } e ^ { s N ( t , \\cos \\theta _ { j } ) } } } } \\end{array}$ esN(t,cos θj) is the predicted ground truth probability and $G ( \\boldsymbol { p } ( \\boldsymbol { x } _ { i } ) )$ is an indicator function. $T ( \\cos \\theta _ { y _ { i } } )$ and $N ( t , \\cos \\theta _ { j } ) = I ( t , \\cos \\theta _ { j } ) \\cos \\theta _ { j } + c$ are the functions to modulate the positive and negative cosine similarities, respectively, where $c$ is a constant, and $I ( t , \\cos \\theta _ { j } )$ denotes the modulation coefficients of negative cosine similarities. In margin-based loss function, e.g, ArcFace, $G ( p ( x _ { i } ) ) = 1$ , $T ( \\cos \\theta _ { y _ { i } } ) = \\cos ( \\theta _ { y _ { i } } + m )$ , and $N ( t , \\cos \\theta _ { j } ) = \\cos \\theta _ { j }$ . It only modifies the positive cosine similarity of each sample to enhance the feature discrimination. As shown in Fig. 1, the modulation coefficients of each sample’ negative cosine similarity $I ( \\cdot )$ is fixed as 1. The recent work, SV-Arc-Softmax emphasizes hard samples by increasing $I ( t , \\cos \\theta _ { j } )$ for hard samples. That is, $G ( p ( x _ { i } ) ) = 1$ and $N ( t , \\mathrm { c o s } _ { \\theta _ { j } } )$ is formulated as follows: ",
+        "bbox": [
+            173,
+            99,
+            825,
+            241
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/164f192e47160be2a8c9e178a78570fbf0fa733ffb44f838140e19e7f73dbd82.jpg",
+        "text": "$$\nN ( t , c o s _ { \\theta _ { j } } ) = \\left\\{ \\begin{array} { l l } { \\cos \\theta _ { j } , } & { T ( \\cos \\theta _ { y _ { i } } ) - \\cos \\theta _ { j } \\geq 0 } \\\\ { t \\cos \\theta _ { j } + t - 1 , } & { T ( \\cos \\theta _ { y _ { i } } ) - \\cos \\theta _ { j } < 0 . } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            250,
+            684,
+            287
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If a sample is defined to be easy, its negative cosine similarity is kept the same as the original one, $\\cos \\theta _ { j }$ ; if as a hard sample, its negative cosine similarity becomes $t \\cos \\theta _ { j } + t - 1$ . That is, as shown in Fig. 1, $I ( \\cdot )$ is a constant and determined by a preset hyper-parameter $t$ . Meanwhile, since $t$ is always larger than 1, $t \\cos \\theta _ { j } + t - 1 > \\cos \\theta _ { j }$ always holds true, which means the model always focuses on hard samples, even in the early training stage. However, the parameter $t$ is sensitive that a large pre-defined value $( e . g . , > 1 . 4 ,$ ) may lead to convergence issue. ",
+        "bbox": [
+            173,
+            295,
+            825,
+            381
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "ADAPTIVE CURRICULAR LEARNING LOSS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            398,
+            467,
+            414
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Next, we present the details of our proposed adaptive curriculum learning loss, which is the first attempt to introduce adaptive curriculum learning into deep face recognition. The formulation of our loss function is also contained in the general form, where $G ( p ( x _ { i } ) ) = 1$ , positive and negative cosine similarity functions are defined as follows: ",
+        "bbox": [
+            174,
+            425,
+            825,
+            482
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e71de3c2800e34715db000420ed9d3c21b7931a7257fdc729ba0d8e86fcc8e46.jpg",
+        "text": "$$\nT ( \\cos \\theta _ { y _ { i } } ) = \\cos ( \\theta _ { y _ { i } } + m ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            491,
+            584,
+            507
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/81cf27c028ca81e81c65bbee2b3713e61cb885dcb9b38a2340cf760045f59f55.jpg",
+        "text": "$$\nN ( t , \\cos _ { \\theta _ { j } } ) = \\left\\{ { \\begin{array} { l l } { \\cos \\theta _ { j } , } & { T ( \\cos \\theta _ { y _ { i } } ) - \\cos \\theta _ { j } \\geq 0 } \\\\ { \\cos \\theta _ { j } ( t + \\cos \\theta _ { j } ) , } & { T ( \\cos \\theta _ { y _ { i } } ) - \\cos \\theta _ { j } < 0 . } \\end{array} } \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            516,
+            691,
+            556
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It should be noted that the positive cosine similarity can adopt any margin-based loss functions and here we adopt ArcFace as the example. As shown in Fig. 1, the modulation coefficient of hard sample negative cosine similarity $I ( t , \\bar { \\theta _ { j } } )$ depends on both the value of $t$ and $\\theta _ { j }$ . In the early training stage, learning from easy samples is beneficial to model convergence. Thus, $t$ should be close to zero and $I ( \\cdot )$ is smaller than 1. Therefore, the weights of hard samples are reduced and the easy samples are emphasized relatively. As training goes on, the model gradually focuses on the hard samples, i.e., the value of $t$ shall increase and $I ( \\cdot )$ is larger than 1. Then, the weights of hard samples are enlarged, which are thus emphasized. Moreover, within the same training stage, $I ( \\cdot )$ is monotonically decreasing with $\\theta _ { j }$ so that harder sample can be assigned with larger coefficient according to its difficultness. The value of the parameter $t$ is automatically estimated in our CurricularFace, otherwise it would require a lot of efforts for manually tuning. ",
+        "bbox": [
+            173,
+            559,
+            825,
+            713
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Adaptive estimation of $t$ It is critical to determine appropriate values of $t$ in different training stages. Ideally the value of $t$ can indicate the model training process. We empirically find the average of positive cosine similarities is a good indicator. However, mini-batch statistic-based methods usually face an issue: when many extreme data are sampled in one mini-batch, the statistics can be vastly noisy and the estimation will be unstable. Exponential Moving Average (EMA) is a common solution to address this issue (Li et al., 2019). Specifically, let $r ^ { ( k ) }$ be the average of the positive cosine similarities of the $k$ -th batch and be formulated as $\\begin{array} { r } { r ^ { ( k ) } = \\sum _ { i } \\cos \\theta _ { y _ { i } } } \\end{array}$ , we have: ",
+        "bbox": [
+            173,
+            729,
+            825,
+            832
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dfcbf495840cb771e84a9713030d6735abc6b7ca3f17e4ea4c246cdd708abeb1.jpg",
+        "text": "$$\nt ^ { ( k ) } = \\alpha r ^ { ( k ) } + ( 1 - \\alpha ) t ^ { ( k - 1 ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            840,
+            591,
+            858
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $t ^ { 0 } = 0$ , $\\alpha$ is the momentum parameter and set to 0.99. As shown in Fig. 2, the parameter $t$ increases with the model training, thus the gradient modulation coefficients’ range of hard sample, $M ( \\cdot ) = 2 \\cos \\theta _ { j } + t$ , also increases. Therefore, hard samples are emphasized gradually. With the EMA, we avoid the hyper-parameter tuning and make the modulation coefficients of hard sample ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: CurricularFace ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            108,
+            367,
+            122
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Input: The deep feature of $_ { i }$ -th sample $x _ { i }$ with its corresponding label $y _ { i }$ , last fully-connected layer parameters $W$ , cosine similarity $\\cos \\theta _ { j }$ between two vectors, embedding network parameters $\\Theta$ , learning rate $\\lambda$ , number of iteration $k$ , parameter $t$ , and margin $m$   \n$k  0$ , $t \\gets 0$ , $m \\gets 0 . 5$ ;   \nwhile not converged do $k \\gets k + 1$ ; if $\\cos ( \\theta _ { y _ { i } } + m ) > \\cos \\theta _ { j }$ then $N ( t , \\cos \\theta _ { j } ) = \\cos \\theta _ { j }$ ; else $\\begin{array} { r l } { \\small \\int _ { - \\infty } ( t , \\cos \\theta _ { j } ) = ( t ^ { ( k ) } + \\cos \\theta _ { j } ) \\cos \\theta _ { j } \\ ; } \\end{array}$ end $T ( \\cos \\theta _ { y _ { i } } ) = \\cos ( \\theta _ { y _ { i } } + m )$ ; Compute the loss $\\mathcal { L }$ by Eq. 8; Compute the back-propagation error of $x _ { i }$ and $W _ { j }$ by Eq. 9; Update the parameters $W$ and $\\Theta$ by: $\\begin{array} { r } { \\boldsymbol { W } ^ { ( k + 1 ) } = \\boldsymbol { W } ^ { ( k ) } - \\lambda ^ { ( k ) } \\frac { \\partial \\boldsymbol { L } } { \\partial \\boldsymbol { W } } , \\Theta ^ { ( k + 1 ) } = \\Theta ^ { ( k ) } - \\lambda ^ { ( k ) } \\frac { \\partial \\boldsymbol { L } } { \\partial x _ { i } } \\frac { \\partial x _ { i } } { \\partial \\Theta ^ { ( k ) } } ; } \\end{array}$ Update the parameter $t$ by Eq. 7; ",
+        "bbox": [
+            173,
+            125,
+            797,
+            337
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "negative cosine similarities $I ( \\cdot )$ adaptive to the current training stage. To sum up, the loss function of our CurricularFace is formulated as follows: ",
+        "bbox": [
+            171,
+            393,
+            821,
+            421
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/536f7904f05df63305b716af8088a4d5c9cde9bad379401e6298da8ef61b9220.jpg",
+        "text": "$$\n\\mathcal { L } = - \\log \\frac { e ^ { s \\cos ( \\theta _ { y _ { i } } + m ) } } { e ^ { s \\cos ( \\theta _ { y _ { i } } + m ) } + \\sum _ { j = 1 , j \\neq y _ { i } } ^ { n } e ^ { s N ( t ^ { ( k ) } , \\cos \\theta _ { j } ) } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            426,
+            665,
+            463
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $N ( t ^ { ( k ) } , \\cos \\theta _ { j } )$ is defined in Eq. 6. The entire training process is summarized in Algorithm 1. ",
+        "bbox": [
+            169,
+            472,
+            820,
+            487
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Fig. 3 illustrates how the loss changes from ArcFace to our CurricularFace during training. Here are some observations: 1) As we excepted, hard samples are suppressed in early training stage but emphasized later. 2) The ratio is monotonically increasing with $c o s \\theta _ { j }$ , since the larger $c o s \\theta _ { j }$ is, the harder the sample is. 3) The positive cosine similarity of a perceptualwell image is often large. However, during the early training stage, the negative cosine similarities of the perceptual-well image may also be large so that it could be classified as the hard one. ",
+        "bbox": [
+            173,
+            493,
+            522,
+            646
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Optimization Next, we show our CurricularFace can be easily optimized by the conventional stochastic gradient descent. Assuming $x _ { i }$ denotes the deep feature of $i$ -th sample which belongs to the $y _ { i }$ class, the input of the proposed function is the logit $f _ { j }$ , where $j$ denotes the $j$ -th class. ",
+        "bbox": [
+            173,
+            662,
+            522,
+            746
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/f87305e9b5fbc1a980f008019d65e600689158bf54c829bba1922eba29835748.jpg",
+        "image_caption": [
+            "Figure 2: Illustrations on the adaptive parameter $t$ (red line) and gradient modulation coefficients $M ( \\cdot ) = 2 \\cos \\theta _ { j } + t$ of hard samples (green area). Since the number of mined hard samples reduces with the model training, the green area $M ( \\cdot )$ is relatively smooth in early stage and there are some burrs in later stage. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            540,
+            501,
+            812,
+            637
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the forwarding process, when $j ~ = ~ y _ { i }$ , it is the same as the ArcFace, i.e., $f _ { j } = s T ( \\cos \\theta _ { y _ { i } } )$ $T ( \\cos \\theta _ { y _ { i } } ) = \\cos ( \\theta _ { y _ { i } } + m )$ . When $j \\neq y _ { i }$ , it has two cases, if $x _ { i }$ is an easy sample, it is the the same as the original softmax, i.e., $f _ { j } = s \\cos \\theta _ { j }$ . Otherwise, it will be modulated as $f _ { j } = s N ( t , \\cos \\theta _ { j } )$ , where $N ( t , \\cos \\theta _ { j } ) = ( t + \\cos \\theta _ { j } ) \\cos \\theta _ { j }$ . In the backward propagation process, the gradient of $x _ { i }$ and $W _ { j }$ can also be divided into three cases and formulated as follows: ",
+        "bbox": [
+            174,
+            752,
+            823,
+            823
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/557bd30aa13c91bd1bda3a7e0f73cdb0c53da3e14ea8abeaafa65b96d5a433ff.jpg",
+        "text": "$$\n\\frac { \\partial L } { \\partial x _ { i } } = \\left\\{ \\begin{array} { l l } { \\frac { \\partial L } { \\partial f _ { y _ { i } } } ( s \\frac { \\sin ( \\theta _ { y _ { i } } + m ) } { \\sin \\theta _ { y _ { i } } } ) W _ { y _ { i } } , } & { j = y _ { i } } \\\\ { \\frac { \\partial L } { \\partial f _ { j } } s W _ { j } , } & { j \\neq y _ { i } , \\mathrm { e a s y } , \\frac { \\partial L } { \\partial W _ { j } } = \\left\\{ \\begin{array} { l l } { \\frac { \\partial L } { \\partial f _ { y _ { i } } } ( s \\frac { \\sin ( \\theta _ { y _ { i } } + m ) } { \\sin \\theta _ { y _ { i } } } ) x _ { i } , } & { j = y _ { i } } \\\\ { \\frac { \\partial L } { \\partial f _ { j } } s x _ { i } , } & { j \\neq y _ { i } , \\mathrm { e a s y } } \\\\ { \\frac { \\partial L } { \\partial f _ { j } } s ( 2 \\cos \\theta _ { j } + t ) W _ { j } } & { j \\neq y _ { i } , \\mathrm { h a r d } } \\end{array} \\right. , } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            189,
+            830,
+            789,
+            890
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Based on the above formulations, we can find the gradient magnitude of the hard sample is determined by two parts, the negative cosine similarity $N ( \\cdot )$ and the value of $t$ . ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/6fdc953ddf73803d98dfe75a3455d0cdaea039f32fc11eb887efddabe900eb44.jpg",
+        "image_caption": [
+            "Figure 3: Illustrations on (ratio between our loss and ArcFace, maximum $c o s \\theta _ { j }$ ) from early (Top) to later (Bottom) training stages. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            112,
+            436,
+            247
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/8f221a3c2e679126845febeae5fba7dce0c06b9e1f1c31cdf7d8c42d5e036352.jpg",
+        "table_caption": [
+            "Table 1: Decision boundaries of popular loss functions. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Loss</td><td rowspan=1 colspan=1>Decision Boundary</td></tr><tr><td rowspan=1 colspan=1>Softmax</td><td rowspan=1 colspan=1>cosOy=cos0j</td></tr><tr><td rowspan=1 colspan=1>SphereFace</td><td rowspan=1 colspan=1>cos(m0y）=cos0j</td></tr><tr><td rowspan=1 colspan=1>CosFace</td><td rowspan=1 colspan=1>cosθy-m=cos0j</td></tr><tr><td rowspan=1 colspan=1>ArcFace</td><td rowspan=1 colspan=1>cos(0y；+m)=cos0j</td></tr><tr><td rowspan=1 colspan=1>SV-Arc-Softmax</td><td rowspan=1 colspan=1>cos(0y+m)=cos0j(easy)cos(0y;+m)=tcos0j+t-i(hard)</td></tr><tr><td rowspan=1 colspan=1>CurricularFace (Ours)</td><td rowspan=1 colspan=1>cos(0yi+m)=cos0j (easy)cos(0y:+m)=(t+cos0j) cos0j(hard)</td></tr></table>",
+        "bbox": [
+            455,
+            126,
+            823,
+            228
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/174f89d0d8f68e4430bc1d0c2f9e719e5327211a23add79401dbf3c16f32dbe5.jpg",
+        "table_caption": [
+            "Table 2: Verification performance of different values of $t$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset (%)</td><td>t=0</td><td>t=0.3</td><td>t=0.7</td><td>t=1</td><td>Adaptive t</td></tr><tr><td>LFW</td><td>99.32</td><td>99.37</td><td>99.42</td><td>99.45</td><td>99.47</td></tr><tr><td>CFP-FP</td><td>95.90</td><td>96.47</td><td>96.66</td><td>93.94</td><td>96.96</td></tr></table>",
+        "bbox": [
+            457,
+            251,
+            820,
+            289
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "DISCUSSIONS WITH SOTA LOSS FUNCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            318,
+            486,
+            332
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Comparison with ArcFace and SV-Arc-Softmax We first discuss the difference between our CurricularFace and the two competitors, ArcFace and SV-Arc-Softmax, from the perspective of the decision boundary in Tab. 1. ArcFace introduces a margin function $T ( \\cos \\theta _ { y _ { i } } ) \\dot { ~ = ~ } \\dot { \\cos ( \\theta _ { y _ { i } } + m ) }$ from the perspective of positive cosine similarity. As shown in Fig. 4, its decision condition changes from $\\cos \\theta _ { y _ { i } } = \\cos \\theta _ { j }$ (i.e., blue line) to $\\cos ( \\dot { \\theta } _ { y _ { i } } + m ) = \\cos \\bar { \\theta } _ { j }$ (i.e., red line) for each sample. SV-Arc-Softmax introduces additional margin from the perspective of negative cosine similarity for hard samples, and the decision boundary becomes $\\cos ( \\theta _ { y _ { i } } + m ) = t \\cos \\theta _ { j } + t - 1$ (i.e., green line). Conversely, we adaptively adjust the weights of hard samples in different training stages. The decision condition becomes $\\cos ( \\theta _ { y _ { i } } + m ) = ( t + \\cos \\theta _ { j } ) \\cos \\theta _ { j }$ (i.e., purple line). During the training stage, the decision boundary for hard samples changes from one purple line (early stage) to another (later stage), which emphasizes easy samples first and hard samples later. ",
+        "bbox": [
+            173,
+            344,
+            825,
+            498
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Comparison with Focal loss Focal loss is a soft mining-based loss, which is formulated as: $G ( \\bar { p ( x ) } ) = \\alpha ( 1 - p ( x _ { i } ) ) ^ { \\beta }$ , where $\\alpha$ and $\\beta$ are modulating factors that need to be tuned manually. The definition of hard samples in Focal loss is ambiguous, since it always focuses on relatively hard samples by reducing the weight of easier samples during the entire training process. In contrast, the definition of hard samples in our CurricularFace is more clear, i.e., mis-classified samples. Meanwhile, the weights of hard samples are adaptively determined in different training stages. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            599
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            623,
+            295,
+            638
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            655,
+            366,
+            670
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets We separately employ CASIA-WebFace (Yi et al., 2014) and refined MS1MV2 (Deng et al., 2019) as our training data for fair comparisons with other methods. We extensively test our method on several popular benchmarks, including LFW (Huang et al., 2007), CFP-FP (Sengupta et al., 2016), CPLFW (Zheng et al., 2018), AgeDB (Moschoglou et al., 2017), CALFW (Zheng et al., 2017), IJB-B (Whitelam et al., 2017), IJB-C (Maze et al., 2018), and MegaFace (KemelmacherShlizerman et al., 2016). ",
+        "bbox": [
+            174,
+            683,
+            825,
+            766
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training Setting We follow Deng et al. (2019) to generate the normalised faces $( 1 1 2 \\times 1 1 2 )$ with five landmarks (Zhang et al., 2016). For the embedding network, we adopt ResNet50 and ResNet100 as in Deng et al. (2019). Our framework is implemented in Pytorch (Paszke et al., 2017). We train models on 4 NVIDIA Tesla P40 (24GB) GPU with batch size 512. The models are trained with SGD algorithm, with momentum 0.9 and weight decay $5 e - 4$ . On CASIA-WebFace, the learning rate starts from 0.1 and is divided by 10 at 28, 38, 46 epochs. The training process is finished at 50 epochs. On MS1MV2, we divide the learning rate at 10, 18, 22 epochs and finish at 24 epochs. We follow the common setting as Deng et al. (2019) to set scale $s = 6 4$ and margin $m = 0 . 5$ , respectively. Last but not least, since we only modify the loss function but use the same backbone as previous methods (e.g., ArcFace), NO additional time complexity is introduced for inference. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/86c3df2d7b59ac8a5f55c0d97984177013a5da36e1db12403de19ad2a54b37ce.jpg",
+        "image_caption": [
+            "Figure 4: From left to right, decision boundaries of ArcFace, SV-Arc-Softmax, and ours. Blue line, red line, green line and purple line denote the decision boundary of Softmax, ArcFace, SV-Arc-Softmax, and ours, respectively. $m$ denotes the angular margin added by ArcFace. $d$ denotes the additional margin of SVArc-Softmax and ours. In SV-Arc-Softmax, $d = ( t - 1 ) \\cos \\theta _ { j } +$ $t - 1$ . In ours, $d = ( t + \\cos \\theta _ { j } - 1 ) \\cos \\theta _ { j }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            114,
+            553,
+            208
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "",
+        "table_caption": [
+            "Table 3: Verification performance of different strategies for setting t. "
+        ],
+        "table_footnote": [],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9afdd5c6df3e867859846790a9f8b63d321161a6b48085b8dba8a391ec959dc7.jpg",
+        "image_caption": [
+            "Figure 5: Illustration on convergence issue with small backbone. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            583,
+            138,
+            799,
+            286
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            339,
+            299,
+            352
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Effects on Fixed vs. Adaptive Parameter $t$ We first investigate the effect of adaptive estimation of $t$ . We choose four fixed values between 0 and 1 for comparison. Specifically, 0 means the modulation coefficient $I ( \\cdot )$ of each hard sample’s negative cosine similarity is always reduced based on its difficultness. In contrast, 1 means the hard samples are always emphasized. 0.3 and 0.7 are between the two cases. Tab. 2 shows that it is more effective to learn from easier samples first and hard samples later based on our adaptively estimated parameter $t$ . ",
+        "bbox": [
+            173,
+            364,
+            825,
+            448
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Effects on Different Statistics for Estimating $t$ We now investigate the effects of several other statistics, i.e., mode of positive cosine similarities in a mini-batch, or mean of the predicted ground truth probability for estimating $t$ in our loss. As Tab. 3 shows, on one hand, the mean of positive cosine similarities is better than the mode. On the other hand, the positive cosine similarity is more accurate than the predicted ground truth probability to indicate the training stages. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            537
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Robustness on Training Convergence As claimed in Li (2019), ArcFace exists divergence issue when using small backbones like MobileFaceNet. As the result, softmax loss must be incorporated for pre-training. To illustrate the robustness of our loss function on convergence issue with small backbone, we use the MobileFaceNet as the network architecture and train it on CASIA-WebFace. As shown in Fig. 5, when the margin $m$ is set to 0.5, the model trained with our loss achieves 99.25 accuracy on LFW, while the model trained with ArcFace does not converge and the loss is NAN at about 2, 400-th step. When the margin $m$ is set to 0.45, both losses can converge, but our loss achieves better performance $( 9 9 . 2 0 \\%$ vs. $9 9 . 1 0 \\%$ ). Comparing the yellow and red curves, since the losses of hard samples are reduced in early training stages, our loss converges much faster in the beginning, leading to lower loss than ArcFace. Later on, the value of our loss is slightly larger than ArcFace, because we emphasize the hard samples in later stages. The results prove that learning from easy samples first and hard samples later is beneficial to model convergence. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            723
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "COMPARISONS WITH SOTA METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            743,
+            442,
+            757
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results on LFW, CFP-FP, CPLFW, AgeDB and CALFW Next, we train our CurricularFace on dataset MS1MV2 with ResNet100, and compare with the SOTA competitors on various benchmarks, including LFW for unconstrained face verification, CFP-FP and CPLFW for large pose variations, AgeDB and CALFW for age variations. As reported in Tab. 4, our CurricularFace achieves comparable result (i.e., $9 9 . 8 0 \\%$ ) with the competitors on LFW where the performance is near saturated. While for both CFP-FP and CPLFW, our method shows superiority over the baselines including general methods, e.g., (Wen et al., 2016), (Cao et al., 2018b), and cross-pose methods, e.g., (Tran et al., 2017), (Peng et al., 2017), (Cao et al., 2018a) and (Deng et al., 2018). As a recent face recognition method, SV-Arc-Softmax achieves better performance than ArcFace, but still worse than Our CurricularFace. Finally, for AgeDB and CALFW, as Tab. 4 shows, our CurricularFace again achieves the best performance than all of the other state-of-the-art methods. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/ad2077616415c04898e4a4c23f3f34c5eb20fbcfacc3fe990cfbfa456a52e979.jpg",
+        "table_caption": [
+            "Table 4: Verification comparison with SOTA methods on various small-scale benchmarks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods (%)</td><td>LFW</td><td>CFP-FP</td><td>CPLFW</td><td>AgeDB</td><td>CALFW</td></tr><tr><td>Center Loss (ECCV&#x27;16)</td><td>98.75</td><td>1</td><td>77.48</td><td>1</td><td>85.48</td></tr><tr><td>SphereFace (CVPR&#x27;17)</td><td>99.27</td><td>一</td><td>81.40</td><td></td><td>90.30</td></tr><tr><td>DRGAN (CVPR&#x27;17)</td><td>1</td><td>93.41</td><td>1</td><td></td><td>1</td></tr><tr><td>Peng et al. (ICCV&#x27;17)</td><td>一</td><td>93.76</td><td>一</td><td></td><td>一</td></tr><tr><td>VGGFace2 (FG&#x27;18)</td><td>99.43</td><td>一</td><td>84.00</td><td></td><td>90.57</td></tr><tr><td>Dream (CVPR&#x27;18)</td><td>1</td><td>93.98</td><td>一</td><td></td><td>一</td></tr><tr><td>Deng et al.(CVPR&#x27;18)</td><td>99.60</td><td>94.05</td><td></td><td></td><td></td></tr><tr><td>ArcFace (CVPR&#x27;19)</td><td>99.77</td><td>98.27</td><td>92.08</td><td>98.15</td><td>95.45</td></tr><tr><td>SV-Arc-Softmax</td><td>99.78</td><td>98.28</td><td>92.83</td><td>97.95</td><td>96.10</td></tr><tr><td>CurricularFace (Ours)</td><td>99.80</td><td>98.37</td><td>93.13</td><td>98.32</td><td>96.20</td></tr></table>",
+        "bbox": [
+            176,
+            136,
+            562,
+            246
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/8450de2b638cc3f106acaece659be04cd073265a9348faf61b8c4bdb35e179ec.jpg",
+        "table_caption": [
+            "Table 5: 1:1 verification TAR ( ${ \\bf @  F A R = }$ 1e − 4) on IJB-B and IJB-C. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods (%)</td><td>IJB-B</td><td>IJB-C</td></tr><tr><td>SENet50 (FG&#x27;18)</td><td>80.0</td><td>84.1</td></tr><tr><td>Multicolumn (BMVC&#x27;18)</td><td>83.1</td><td>86.2</td></tr><tr><td>DCN (ECCV&#x27;18)</td><td>84.9</td><td>88.5</td></tr><tr><td>ArcFace-R100 (CVPR&#x27;19)</td><td>94.2</td><td>95.6</td></tr><tr><td>Adacos (CVPR&#x27;19)</td><td>1</td><td>92.4</td></tr><tr><td>P2SGrad (CVPR&#x27;19)</td><td>1</td><td>92.3</td></tr><tr><td>PFE (ICCV&#x27;19)</td><td>一</td><td>93.3</td></tr><tr><td>SV-Arc-Softmax</td><td>93.6</td><td>95.2</td></tr><tr><td>CurricularFace (Ours)</td><td>94.8</td><td>96.1</td></tr></table>",
+        "bbox": [
+            571,
+            136,
+            821,
+            244
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b48d7333b3b7c7363bf6c1c5a15e05f82499afee54ba04b655a50257cb9bcbc1.jpg",
+        "table_caption": [
+            "Table 6: Verification comparison with SOTA methods on MegaFace Challenge 1 using FaceScrub as the probe set. Left table: ‘Id’ refers to the rank-1 face identification accuracy with 1M distractors, and ‘Ver’ refers to the face verification TAR at $1 0 ^ { - 6 }$ FAR. ‘R’ refers to data refinement on both probe set and 1M distractors. Right figure: Rank-1 identification results of recent SOTA methods on probe set refined from ArcFace. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>CASIA(%)</td><td>Id</td><td>Ver</td><td>MS1MV2(%)</td><td>Id</td><td>Ver</td><td>CosFace(CVPR’18)- 97.91</td><td></td></tr><tr><td>Contrastive Loss (CVPR&#x27;14)</td><td>65.21</td><td>78.86</td><td>CosFace-MS1MV2-R100</td><td>80.56</td><td>96.56</td><td></td><td></td></tr><tr><td>Triplet (CVPR&#x27;15)</td><td>64.79</td><td>78.32</td><td>CosFace-MS1MV2-R100, R</td><td>97.91</td><td>97.91</td><td></td><td>Adacos (CVPR&#x27;19)-97.41</td></tr><tr><td>Center Loss (ECCV&#x27;16)</td><td>65.49</td><td>80.14</td><td>ArcFace-MS1MV2-R100</td><td>81.03</td><td>96.98</td><td></td><td></td></tr><tr><td>SphereFace(CVPR&#x27;17)</td><td>72.73</td><td>85.56</td><td>ArcFace-MS1MV2-R100, R</td><td>98.35</td><td>98.48</td><td></td><td>P2SGrad (CVPR’19)-97.25</td></tr><tr><td>CosFace (CVRP&#x27;18)</td><td>77.11</td><td>89.88</td><td>PFE (ICCV&#x27;19)</td><td>78.95</td><td>92.51</td><td></td><td>AreFace (CVPR&#x27;19)-98.35</td></tr><tr><td>AM-Softmax (SPL&#x27;18)</td><td>72.47</td><td>84.44</td><td>Adacos,R(CVPR&#x27;19&#x27;)</td><td>97.41</td><td></td><td></td><td></td></tr><tr><td>ArcFace-CASIA-R50 (CVPR&#x27;19)</td><td>77.50</td><td>92.34</td><td>P2SGrad,R(CVPR&#x27;19&#x27;)</td><td>97.25</td><td></td><td></td><td>SV-Arc-Softmax (arXiv&#x27;19)- 97.14</td></tr><tr><td>ArcFace-CASIA-R50, R</td><td>91.75</td><td>93.69</td><td>SV-Arc-Softmax,R</td><td>97.14</td><td>97.57</td><td></td><td></td></tr><tr><td>Ours-CASIA-R50</td><td>77.65</td><td>92.91</td><td>Ours-MS1MV2-R100</td><td>81.26</td><td>97.26</td><td></td><td>CurricularFace (Ours)-98.71</td></tr><tr><td>Ours-CASIA-R50, R</td><td>92.48</td><td>94.55</td><td>Ours-MS1MV2-R100, R</td><td>98.71</td><td>98.64</td><td>97</td><td></td></tr></table>",
+        "bbox": [
+            176,
+            327,
+            825,
+            426
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results on IJB-B and IJB-C The IJB-B dataset contains 1, 845 subjects with 21.8K still images and 55K frames from 7, 011 videos. In the 1:1 verification, there are 10, 270 positive matches and 8M negative matches. The IJB-C dataset is a further extension of IJB-B, which contains about 3, 500 identities with a total of 31, 334 images and 117, 542 unconstrained video frames. In the 1:1 verification, there are 19, 557 positive matches and 15, 638, 932 negative matches. On IJB-B and IJB-C datasets, we employ MS1MV2 and the ResNet100 for a fair comparison with recent methods. We follow the testing protocol in ArcFace and take the average of the image features as the corresponding template representation without bells and whistles. Tab. 5 exhibits the performance of different methods, e.g., Multicolumn (Xie & Zisserman, 2018), DCN (Xie et al., 2018), Adacos (Zhang et al., 2019a), P2SGrad (Zhang et al., 2019b), PFE (Shi et al., 2019) and SV-Arc-Softmax (Wang et al., 2018b) on IJB-B and IJB-C 1:1 verification, our method again achieves the best performance. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            603
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results on MegaFace Finally, we evaluate the performance on the MegaFace Challenge. The gallery set of MegaFace includes 1M images of 690K subjects, and the probe set includes 100K photos of 530 unique individuals from FaceScrub. We report the two testing results under two protocols (large or small training set). Here, we use CASIA-WebFace and MS1MV2 under the small protocol and large protocol, respectively. In Tab. 6, our method achieves the best singlemodel identification and verification performance under both protocols, surpassing the recent strong competitors, e.g., CosFace, ArcFace, Adacos, P2SGrad and PFE. We also report the results following the ArcFace testing protocol, which refines both the probe set and the gallery set. As shown from the figure in Tab. 6, our method still clearly outperforms the competitors and achieves the best performance on both verification and identification. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            758
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            781,
+            297,
+            796
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a novel Adaptive Curriculum Learning Loss that embeds the idea of adaptive curriculum learning into deep face recognition. Our key idea is to address easy samples in the early training stage and hard ones in the later stage. Our method is easy to implement and robust to converge. Extensive experiments on popular facial benchmarks demonstrate the effectiveness of our method compared to the state-of-the-art competitors. Following the main idea of this work, future research can be expanded in various aspects, including designing a better function $N ( \\cdot )$ for negative cosine similarity that shares similar adaptive characteristic during training, and investigating the effects of noise samples that could be optimized as hard samples. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sumit Basu and Janara Christensen. Teaching classification boundaries to humans. In AAAI, 2013. ",
+        "bbox": [
+            173,
+            126,
+            820,
+            141
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Jer´ ome Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In ˆ ICML, 2009. ",
+        "bbox": [
+            174,
+            148,
+            823,
+            178
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaidi Cao, Yu Rong, Cheng Li, Xiaoou Tang, and Chen Change Loy. Pose-robust face recognition via deep residual equivariant mapping. In CVPR, 2018a. ",
+        "bbox": [
+            173,
+            185,
+            823,
+            215
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Qiong Cao, Li Shen, Weidi Xie, Omkar M. Parkhi, and Andrew Zisserman. Vggface2: A dataset for recognising faces across pose and age. In FG, 2018b. ",
+        "bbox": [
+            173,
+            222,
+            823,
+            252
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Beidi Chen, Weiyang Liu, Animesh Garg, Zhiding Yu, Anshumali Shrivastava, and Anima Anandkumar. Angular visual hardness. In ICML Workshop on Deep Phenomena, 2019. ",
+        "bbox": [
+            174,
+            260,
+            823,
+            290
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sheng Chen, Yang Liu, Xiang Gao, and Zhen Han. Mobilefacenets: Efficient cnns for accurate real-time face verification on mobile devices. In CCBR, 2018. ",
+        "bbox": [
+            174,
+            296,
+            823,
+            327
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jiankang Deng, Shiyang Cheng, Niannan Xue, Yuxiang Zhou, and Stefanos Zafeiriou. Uv-gan: Adversarial facial uv map completion for pose-invariant face recognition. In CVPR, 2018. ",
+        "bbox": [
+            173,
+            333,
+            821,
+            363
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jiankang Deng, Jia Guo, and Stefanos Zafeiriou. ArcFace: Additive angular margin loss for deep face recognition. In CVPR, 2019. ",
+        "bbox": [
+            173,
+            371,
+            821,
+            400
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gary B. Huang, Manu Ramesh, Tamara Berg, and Erik Learned-Miller. Labeled faces in the wild: A database for studying face recognition in unconstrained environments. Technical Report 07-49, University of Massachusetts, Amherst, October 2007. ",
+        "bbox": [
+            176,
+            407,
+            823,
+            452
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ira Kemelmacher-Shlizerman, Steven M Seitz, Daniel Miller, and Evan Brossard. The megaface benchmark: 1 million faces for recognition at scale. In CVPR, 2016. ",
+        "bbox": [
+            174,
+            458,
+            823,
+            488
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "M Pawan Kumar, Benjamin Packer, and Daphne Koller. Self-paced learning for latent variable models. In NIPS, 2010. ",
+        "bbox": [
+            174,
+            496,
+            821,
+            525
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Buyu Li, Yu Liu, and Xiaogang Wang. Gradient harmonized single-stage detector. In AAAI, 2019. ",
+        "bbox": [
+            171,
+            532,
+            818,
+            549
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Weiyang Li, Yandong Wen, Zhiding Yu, Ming Li, Bhiksha Raj, and Le Song. Sphereface: Deep hypersphere embedding for face recognition. In CVPR, 2017. ",
+        "bbox": [
+            174,
+            556,
+            821,
+            587
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xianyang Li. Airface: Lightweight and efficient model for face recognition. arXiv:1907.12256, 2019. ",
+        "bbox": [
+            174,
+            593,
+            821,
+            622
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense object ´ detection. In ICCV, pp. 2980–2988, 2017. ",
+        "bbox": [
+            173,
+            631,
+            823,
+            660
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Weiyang Liu, Yandong Wen, Zhiding Yu, and Meng Yang. Large-margin softmax loss for convolutional neural networks. In ICML, 2016. ",
+        "bbox": [
+            173,
+            667,
+            823,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Brianna Maze, Jocelyn Adams, James A Duncan, Nathan Kalka, Tim Miller, Charles Otto, Anil K Jain, W Tyler Niggel, Janet Anderson, Jordan Cheney, et al. Iarpa janus benchmark-c: Face dataset and protocol. In ICB, 2018. ",
+        "bbox": [
+            174,
+            704,
+            825,
+            748
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Stylianos Moschoglou, Athanasios Papaioannou, Christos Sagonas, Jiankang Deng, Irene Kotsia, and Stefanos Zafeiriou. Agedb: the first manually collected, in-the-wild age database. In CVPR Workshops, 2017. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            799
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in PyTorch. In NIPS Autodiff Workshop, 2017. ",
+        "bbox": [
+            173,
+            806,
+            825,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xi Peng, Xiang Yu, Kihyuk Sohn, Dimitris Metaxas, and Manmohan Chandraker. Reconstructionbased disentanglement for poseinvariant face recognition. In ICCV, 2017. ",
+        "bbox": [
+            174,
+            858,
+            821,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Florian Schroff, Dmitry Kalenichenko, and James Philbin. Facenet: A unified embedding for face recognition and clustering. In CVPR, 2015. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "S. Sengupta, J.-C. Chen, C. Castillo, V. M. Patel, R. Chellappa, and D.W. Jacobs. Frontal to profile face verification in the wild. In WACV, 2016. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yichun Shi, Anil K Jain, and Nathan D Kalka. Probabilistic face embeddings. In ICCV, 2019. ",
+        "bbox": [
+            173,
+            140,
+            794,
+            156
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Abhinav Shrivastava, Abhinav Gupta, and Ross Girshick. Training region-based object detectors with online hard example mining. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            165,
+            823,
+            194
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Luan Tran, Xi Yin, and Xiaoming Liu. Disentangled representation learning GAN for pose-invariant face recognition. In CVPR, 2017. ",
+        "bbox": [
+            171,
+            202,
+            825,
+            232
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hao Wang, Yitong Wang, Zheng Zhou, Xing Ji, Dihong Gong, Jingchao Zhou, Zhifeng Li, and Wei Liu. Cosface: Large margin cosine loss for deep face recognition. In CVPR, 2018a. ",
+        "bbox": [
+            171,
+            239,
+            823,
+            270
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaobo Wang, Shuo Wang, Shifeng Zhang, Tianyu Fu, Hailin Shi, and Tao Mei. Support vector guided softmax loss for face recognition. arXiv:1812.11317, 2018b. ",
+        "bbox": [
+            173,
+            277,
+            823,
+            308
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yandong Wen, Kaipeng Zhang, Zhifeng Li, and Yu Qiao. A discriminative feature learning approach for deep face recognition. In ECCV, 2016. ",
+        "bbox": [
+            171,
+            315,
+            825,
+            344
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cameron Whitelam, Emma Taborsky, Austin Blanton, Brianna Maze, Jocelyn Adams, Tim Miller, Nathan Kalka, Anil K Jain, James A Duncan, Kristen Allen, et al. Iarpa janus benchmark-b face dataset. In CVPR Workshops, 2017. ",
+        "bbox": [
+            176,
+            353,
+            820,
+            397
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Weidi Xie and Andrew Zisserman. Multicolumn networks for face recognition. In BMVC, 2018. ",
+        "bbox": [
+            171,
+            405,
+            805,
+            421
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Weidi Xie, Li Shen, and Andrew Zisserman. Comparator networks. In ECCV, 2018. ",
+        "bbox": [
+            174,
+            429,
+            730,
+            444
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dong Yi, Zhen Lei, Shengcai Liao, and Stan Z. Li. Learning face representation from scratch. arXiv:1411.7923, 2014. ",
+        "bbox": [
+            173,
+            453,
+            821,
+            482
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaipeng Zhang, Zhanpeng Zhang, Zhifeng Li, and Yu Qiao. Joint face detection and alignment using multitask cascaded convolutional networks. IEEE Signal Processing Letters, 23(10):1499–1503, 2016. ",
+        "bbox": [
+            174,
+            489,
+            825,
+            534
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiao Zhang, Rui Zhao, Yu Qiao, Xiaogang Wang, and Hongsheng Li. Adacos: Adaptively scaling cosine logits for effectively learning deep face representations. In CVPR, 2019a. ",
+        "bbox": [
+            171,
+            541,
+            823,
+            571
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiao Zhang, Rui Zhao, Junjie Yan, Mengya Gao, Yu Qiao, Xiaogang Wang, and Hongsheng Li. P2sgrad: Refined gradients for optimizing deep face models. In CVPR, 2019b. ",
+        "bbox": [
+            173,
+            579,
+            821,
+            609
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tianyue Zheng, Weihong Deng, and Jiani Hu. Cross-age lfw: A database for studying cross-age face recognition in unconstrained environments. arXiv:1708.08197, 2017. ",
+        "bbox": [
+            173,
+            617,
+            823,
+            647
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tianyue Zheng, Weihong Deng, and Jiani Hu. Cross-pose lfw: A database for studying cross-pose face recognition in unconstrained environments. Technical Report 18-01, Beijing University of Posts and Telecommunications, February 2018. ",
+        "bbox": [
+            178,
+            655,
+            823,
+            699
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tianyi Zhou and Jeff Bilmes. Minimax curriculum learning: Machine teaching with desirable difficulties and scheduled diversity. In ICLR, 2018. URL https://openreview.net/forum? id $=$ BywyFQlAW. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            750
+        ],
+        "page_idx": 9
+    }
+]

parse/train/H38f_9b90BO/H38f_9b90BO.md

@@ -0,0 +1,604 @@
+# TOWARDS ROBUST GRAPH NEURAL NETWORKS AGAINST LABEL NOISE
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Massive labeled data have been used in training deep neural networks, thus label noise has become an important issue therein. Although learning with noisy labels has made great progress on image datasets in recent years, it has not yet been studied in connection with utilizing GNNs to classify graph nodes. In this paper, we propose a method, named LPM, to address the problem using Label Propagation (LP) and Meta learning. Different from previous methods designed for image datasets, our method is based on a special attribute (label smoothness) of graphstructured data, i.e., neighboring nodes in a graph tend to have the same label. A pseudo label is computed from the neighboring labels for each node in the training set using LP; meta learning is utilized to learn a proper aggregation of the original and pseudo label as the final label. Experimental results demonstrate that LPM outperforms state-of-the-art methods in graph node classification task with both synthetic and real-world label noise. Source code to reproduce all results will be released.
+
+# 1 INTRODUCTION
+
+Deep Neural Networks (DNNs) have achieved great success in various domains, but the necessity of collecting large amount of samples with high-quality labels is both expensive and time-consuming. To address this problem, cheaper alternatives have emerged. For example, the onerous labeling process can be completed on some crowdsourced system like Amazon Mechanical Turk 1. Besides, we can collect labeled samples from web with search engines and social media. However, all these methods are prone to produce noisy labels of low quality. As is shown in recent research (Zhang et al., 2016b), an intractable problem is that DNNs can easily overfit to noisy labels, which dramatically degrades the generalization performance. Therefore, it is necessary and urgent to design some valid methods for solving this problem.
+
+Graph Neural Networks (GNNs) have aroused keen research interest in recent years, which resulted in rapid progress in graph-structured data analysis (Kipf & Welling, 2016; Velickovic et al., 2017; Xu et al., 2018; Hou et al., 2019; Wang & Leskovec, 2020). Graph node classification is the mostcommon issue in GNNs. However, almost all the previous works about label noise focus on image classification problem and handling noisy labels in the task of graph node classification with GNNs has not been studied yet. Fortunately, most edges in the graph-structured datasets are intra-class edges (Wang & Leskovec, 2020), indicating that a node’s label can be estimated by its neighbor nodes’ labels. In this paper, we utilize this special attribute of graph data to alleviate the damages caused by noisy labels. Moreover, meta learning paradigm serves as a useful tool for us to learn a proper aggregation between origin labels and pseudo labels as the final labels.
+
+The key contributions of this paper are as follows:
+
+• To the best of our knowledge, we are the first to focus on the label noise existing in utilizing GNNs to classify graph nodes, which may serve as a beginning for future research towards robust GNNs against label noise.
+
+• We utilize meta-learning to learn how to aggregate origin labels and pseudo labels properly to get more credible supervision instead of learning to re-weight different samples.
+
+We experimentally show that our LPM outperforms state-of-the-art algorithms in utilizing GNNs to classify graph nodes with both synthetic and real-world label noise.
+
+# 2 RELATED WORK
+
+# 2.1 GRAPH NEURAL NETWORKS
+
+To start, we use $\mathcal { G } = ( \nu , \mathcal { E } , \mathcal { X } )$ to denote a graph whose nodes set is $\nu$ and edges set is $\mathcal { E }$ , and $\mathcal { X } \in R ^ { n \times d }$ is the input feature matrix, where $n$ denotes the number of nodes in the graph and $d$ is the dimension of the input feature vector of each node. We use $e _ { u , v } \in \mathcal { E }$ to denote the edge that connects node $u$ and $v$ . For each node $v \in \mathcal V$ , its neighbor nodes set can be donated as $\mathcal { N } _ { v } = \{ u : e _ { u , v } \in \mathcal { E } \}$ . For node classification task, the goal of GNNs is to learn optimal mapping function $f ( \cdot )$ to predict the class label $y _ { v }$ for node $v$ . Generally speaking, GNNs follows a framework including aggregation and combination in each layer. Different GNNs have proposed different ways of aggregation and combination. In general, the $k$ -th layer of a GNN reads
+
+$$
+a _ { v } ^ { ( k ) } = A g g r e g a t e ^ { ( k ) } ( \{ h _ { u } ^ { ( k - 1 ) } : u \in \mathcal { N } ( v ) \} ) , h _ { v } ^ { ( k ) } = C o m b i n e ^ { ( k ) } ( h _ { v } ^ { ( k - 1 ) } , a _ { v } ^ { ( k ) } ) ,
+$$
+
+where $h _ { v } ^ { ( k ) }$ is the output for $k$ -th layer of node $v$ , $h _ { v } ^ { ( 0 ) }$ is the input vector of node $v$
+
+# 2.2 LABEL PROPAGATION
+
+In Label Propagation (LP), node labels are propagated and aggregated along the edges in the graph (Zhou et al., 2004; Zhu et al., 2005; Wang & Zhang, 2007; Karasuyama & Mamitsuka, 2013). There are some works which were designed to improve the performance of label propagation. For example, Gong et al. (2016) proposed a novel iterative label propagation algorithm which explicitly optimizes the propagation quality by manipulating the propagation sequence to move from simple to difficult examples; Zhang et al. (2020) introduces a triple matrix recovery mechanism to remove noise from the estimated soft labels during propagation. Label propagation has been applied in semi-supervised image classification task. For example, Gong et al. (2017) used a weighted Knearest neighborhood graph to bridge the datapoints so that the label information can be propagated from the scarce labeled examples to unlabeled examples along the graph edges. Park et al. (2020) proposed a novel framwork to propagate the label information of the sampled data (reliable) to adjacent data along a similarity based graph. Compared to these methods, we utilize the intrinsic graph structure instead of handcrafted graph to propagate clean labels information, which is more reliable for graph-structured data. Besides, GNNs are utilized by us to extract features and classify nodes for graph-structured data.
+
+# 2.3 META-LEARNING BASED METHODS AGAINST NOISY LABELS
+
+Meta-learning aims to learn not only neural networks’ weights, but also itself, such as hand-designed parameters, optimizer and so on (Andrychowicz et al., 2016; Finn et al., 2017). Several works have utilized meta-learning paradigm to deal with label noise. For example, Li et al. (2019) has proposed to find noise-tolerant model parameters by keeping the consistency between the output of teacher and student networks, and Li et al. (2017b) trains the teacher networks with samples with clean labels and then transfer the knowledge to student networks so that the student can learn correctly even if the existence of mislabeled data. Besides, Ren et al. (2018); Jenni & Favaro (2018); Shu et al. (2019) utilize meta-learning paradigm to re-weight samples, i.e., weight samples with clean labels more and weight mislabeled samples less. The weighting factors are optimized by gradient decent or generated by a network to minimizes the loss on a small amount of samples with correct labels. In contrast, meta-learning paradigm is utilized in this paper to learn how to aggregate origin labels and pseudo labels properly. We can get more credible supervision by combining the original label information with the label information provided by LP properly.
+
+![](images/88e328481af02f8079b2ba69be71949f441f9d355e551c983965101d2e93aa17.jpg)  
+Figure 1: Illustration of label propagation in our method. The two types of nodes are distinguished by two colours (blue and green). The nodes surrounded by dotted line are training nodes $\mathcal { D } _ { t r a i n }$ whose label may be incorrect and those surrounded by solid line are clean sets $\mathcal { D } _ { c l e a n }$ . In Figure.1(b), one half of every training node is pseudo label predicted by LP and the other half is original label. Some nodes’ (node 5,7) pseudo labels are the same with their original labels, we select them $\mathcal { D } _ { s e l e c t }$ to train GNNs and inject them to clean sets for better label propagation. We can get proper labels for the left nodes $\mathcal { D } _ { l e f t }$ (node 6,8,9,10) based on meta learning.
+
+# 3 METHODS
+
+# 3.1 PRELIMINARIES
+
+Given a graph data with $n$ nodes and their labels $\mathcal { D } \ = \ \{ ( x _ { 0 } , y _ { 0 } ) , ( x _ { 1 } , y _ { 1 } ) , . . . , ( x _ { n - 1 } , y _ { n - 1 } ) \}$ , where $x _ { j }$ is the $j$ -th node and $y _ { j } \in \{ 0 , 1 \} ^ { c }$ is the label over $c$ classes. $\begin{array} { r l } { \mathcal { D } _ { t r a i n } } & { { } = } \end{array}$ $\left\{ { \left( x _ { 0 } , y _ { 0 } \right) } , { \left( x _ { 1 } , y _ { 1 } \right) } , . . . , { \left( x _ { s - 1 } , y _ { s - 1 } \right) } \right\}$ are training nodes with noisy labels. Our goal is to enable the GNNs $f ( x _ { j } ; w )$ trained with noisy sets $\mathcal { D } _ { t r a i n }$ can also generalize well on test nodes. $\cdot$ is the learnable parameters of GNNs. In our method, $m$ nodes with true labels $\mathcal { D } _ { c l e a n } ~ =$ $\{ ( x _ { s } , y _ { s } ) , ( x _ { s + 1 } , y _ { s + 1 } ) , . . . , ( x _ { s + m - 1 } , y _ { s + m - 1 } ) \}$ in the graph are provided as the initial clean sets $( m \ll s )$ . GCN (Kipf & Welling, 2016) and GAT (Velickovic et al., 2017) are utilized in our experiments to extract features and classify nodes. Our method includes two main parts: label propagation and label aggregation. We will go into details about these two parts in the following section 3.2 and section 3.3.
+
+# 3.2 LABEL PROPAGATION
+
+Label Propagation is based on the label smoothness that two connected nodes tend to have the same label. Therefore, the weighted average of neighbor nodes’ label of a node is similar to this node��s true label. An illustration of LP part in our method can be found in Figure. 1. The first step of LP is to construct an appropriate neighborhood graph. A common choice is $\mathbf { k }$ -nearest graph (Iscen et al., 2019; Liu et al., 2018) but there is an intrinsic graph structure (adjacency matrix $A$ ) in graph data, so our similarities matrix $W$ with zero diagonal can be constructed with $A$ , whose elements $\cdot$ are pairwise similarities between node $i$ and node $j$ :
+
+$$
+= \frac { A _ { i , j } } { d ( h _ { i } , h _ { j } ) + \varepsilon } ,
+$$
+
+where $h _ { i } , h _ { j }$ are the feature vectors extracted by GNNs for node $i$ and node $j , \ d ( \cdot , \cdot )$ is a distance measure (e.g.,Euclidean distance). $\varepsilon$ is an infinitesimal. Note that we can get $W$ with time complexity $\mathcal { O } ( | \mathcal { E } | )$ instead of $\mathcal { O } ( n ^ { 2 } )$ because $A$ is a sparse matrix whose edge lists are given. Then we can normalize the similarities matrix $W$ :
+
+$$
+S = D ^ { - 1 / 2 } W D ^ { - 1 / 2 } ,
+$$
+
+$D$ atrix withbe the sof $( i , i )$ -value to be the sum of thbel matrix in LP iteration $i$ -th rowand the f -t $W$ . Low $Y ^ { ( k ) } =$ $[ y _ { 1 } ^ { ( k ) } , . . . , y _ { n } ^ { ( k ) } ] ^ { T } \ \in \ \mathbb { R } ^ { n \times c }$ $k$ $i$ $y _ { i } ^ { ( k ) }$ predicted label distribution for node $i$ . When $k = 0$ , the initial label matrix $Y ^ { ( 0 ) } = [ y _ { 1 } ^ { ( 0 ) } , . . . , y _ { n } ^ { ( 0 ) } ] ^ { T }$
+
+consists of one-hot label vectors for $i = s , s + 1 , . . . , s + m - 1$ (i.e., initial clean sets) or zero vectors otherwise. The LP (Zhu et al., 2005) in iteration $k$ can be formulated as:
+
+$$
+Y ^ { ( k + 1 ) } = S Y ^ { ( k ) } ,
+$$
+
+$$
+y _ { i } ^ { ( k + 1 ) } = y _ { i } ^ { ( 0 ) } , \forall i \in [ s , s + m - 1 ]
+$$
+
+In Eq. (4), every node’s label in the $( k + 1 )$ -th iteration equals the weighted average of its neighbor nodes’ labels in $k$ -th iteration. In this way, the clean sets propagate labels to the noisy training nodes according to normalized edge weights. And then in Eq. (5), the labels of clean sets nodes are reset to their initial values. The reason is that we can take full advantage of the tiny minority of clean nodes and in case that the effect of clean sets fade away.
+
+Co-teaching (Han et al., 2018) and $\mathbf { C o }$ -teaching plus (Yu et al., 2019) have been proposed to train DNNs robustly against label noise. There are two DNNs which select samples with small loss from noisy training sets to train each other. Our method is similar to theirs to some extent because LP is utilized by us to select true-labeled samples from Gradients	descent $\mathcal { D } _ { t r a i n }$ for training. However, instead of taking the nodes with small loss as true-labeled nodes, we select the nodes $\mathcal { D } _ { s e l e c t }$ whose original labels are same with pseudo labels for training. Original labels of $\mathcal { D } _ { s e l e c t }$ are credible and we also inject them to initial clean sets $\mathcal { D } _ { c l e a n }$ for better LP in next epoch. This is why our method can achieve better performance even if few true-labeled nodes are provided.
+
+# 3.3 META-LEARNING BASED LABEL AGGREGATION
+
+![](images/459eb21005021877ff65bf3593cb8c4eb0cf30cf0af655437c1a8af9d5e2b904.jpg)  
+Figure 2: Computation graph of meta-learning based label aggregation.
+
+In section 3.2, the selected training nodes (node 5,7 in Figure.1) have been utilized for training and LP but the left training nodes $\mathcal { D } _ { l e f t }$ (node 6,8,9,10 in Figure.1) with abundant information haven’t been fully exploited. In this section, we mine the abundant and precious information from $\mathcal { D } _ { l e f t }$ via meta learning. The computation process of label aggregation is shown in Figure. 2.
+
+For $\forall ( x _ { j } , y _ { j } ) \in \mathcal { D } _ { l e f t }$ , we can get two loss values:
+
+$$
+\begin{array} { r } { l _ { 1 } = l o s s ( \hat { y } _ { j } , y _ { j } ) , } \\ { l _ { 2 } = l o s s ( \hat { y } _ { j } , \tilde { y } _ { j } ) , } \end{array}
+$$
+
+where $\hat { y } _ { j }$ is the label predicted by GNNs for training node $j$ and $\tilde { y } _ { j }$ is the pseudo label predicted by LP for node $j$ . We can also get final label ${ \overline { { y } } } _ { j }$ for node $j$ by aggregating original label $y _ { j }$ and pseudo label $\tilde { y } _ { j }$ :
+
+$$
+\overline { { y } } _ { j } = \lambda _ { j } y _ { j } + ( 1 - \lambda _ { j } ) \widetilde { y } _ { j } , \lambda _ { j } \in [ 0 , 1 ]
+$$
+
+where $\lambda$ is the aggregation coefficient. Some previous methods designed a weighting function mapping training loss to sample weights for noisy label problems (Kumar et al., 2010; Ren et al., 2018; Shu et al., 2019). Instead, we utilize a 3-layer multi-layer perceptron (MLP) as the aggregation network $g ( \cdot ; \cdot )$ to map loss values to aggregation coefficient $\lambda _ { j }$ :
+
+$$
+\lambda _ { j } = g ( l _ { 1 } \parallel l _ { 2 } ; \theta ) = \lambda _ { j } ( \theta ; w ) ,
+$$
+
+Where $l _ { 1 } \parallel l _ { 2 }$ is a 2-dimensional vector which is the concatenation of $l _ { 1 }$ and $l _ { 2 }$ and $\theta$ is the weights of aggregation network $g$ . The rationality lies on a consensus that samples’ loss values are affiliated with the credibility of samples’ original labels (Kumar et al., 2010; Shu et al., 2019; Yu et al., 2019). The MLP or aggregation networks’ input layer are 2 neurons and its output layer is one neuron, which can be an approximator to almost any continuous functions. The activation function of the last layer is sigmoid function to ensure that output $\lambda _ { j } \in [ 0 , 1 ]$ . We can get the training loss $L _ { j } ^ { t r }$ for node $j$ :
+
+$$
+L _ { j } ^ { t r } ( w , \theta ) = l o s s ( \hat { y } _ { j } ( w ) , \overline { { y } } _ { j } ( \theta ) ) ,
+$$
+
+Then we can backward on the GNNs:
+
+$$
+\hat { w } _ { t } \big ( \theta _ { t } \big ) = w _ { t } - \frac { \alpha } { \mid \mathcal { D } _ { l e f t } \mid } \sum _ { ( x _ { j } , y _ { j } ) \in \mathcal { D } _ { l e f t } } \nabla _ { w } L _ { j } ^ { t r } \big ( w , \theta _ { t } \big ) | _ { w _ { t } } ,
+$$
+
+where $\alpha$ is the learning rate of GNNs. Then we can get the loss $L ^ { c }$ on clean sets $\mathcal { D } _ { c l e a n }$
+
+$$
+L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) = \frac { 1 } { | \mathcal { D } _ { c l e a n } ~ | } \sum _ { ( x _ { i } , y _ { i } ) \in \mathcal { D } _ { c l e a n } } l o s s ( f ( x _ { i } ; \hat { w } _ { t } ( \theta _ { t } ) ) , y _ { i } ) ,
+$$
+
+Where $f ( x _ { i } ; \hat { w } _ { t } ( \theta _ { t } ) )$ is the output of GNNs. Then we can utilize $L ^ { c }$ to update the weights of aggregation network:
+
+$$
+\theta _ { t + 1 } = \theta _ { t } - \beta \nabla _ { \theta } L ^ { c } ( \hat { w } ( \theta ) ) | _ { \theta _ { t } } ,
+$$
+
+where $\beta$ is the learning rate of aggregation network. Finally, GNNs’ weights can be updated:
+
+$$
+w _ { t + 1 } = w _ { t } - \frac { \alpha } { | \mathcal { D } _ { l e f t } ~ | } \sum _ { ( x _ { j } , y _ { j } ) \in \mathcal { D } _ { l e f t } } \nabla _ { w } L _ { j } ^ { t r } ( w , \theta _ { t + 1 } ) | _ { w _ { t } } .
+$$
+
+To some extent, this part is similar to re-weight based methods (Ren et al., 2018; Shu et al., 2019). However, LPM has two significant advantages. Firstly, re-weight based methods can not remove the damages caused by incorrect labels because they assign every noisy training sample a positive weight while LPM potentially has the ability to take full advantage of noisy samples positively. Secondly, LPM can generate comparatively credible labels for other usages while re-weight or some other methods can not. Algorithm. 1 shows all the steps of our algorithm.
+
+# 3.4 CONVERGENCE OF LPM
+
+Here we show theoretically that the loss functions will converge to critical points under some mild conditions. The detailed proof of the following theorems will be provided in Appendix C.
+
+Theorem 1 Suppose the loss function loss is $L$ -Lipschitz smooth, and $\lambda ( \cdot )$ is differential with a $\delta$ - bounded gradient, twice differential with its Hessian bounded by $\boldsymbol { B }$ with respect to $\theta$ . Let the learning rate $\alpha _ { t } = \operatorname* { m i n } \{ 1 , { \frac { k } { T } } \}$ , for some $k > 0$ , such that $\begin{array} { r } { { \frac { k } { T } } < 1 } \end{array}$ and learning rate $\beta _ { t }$ a monotone descent sequence, $\begin{array} { r } { \beta _ { t } = \operatorname* { m i n } \{ \frac { 1 } { L } , \frac { c } { \sqrt { T } } \} } \end{array}$ for some $c > 0$ , such that $L \leq { \frac { c } { \sqrt { T } } }$ and $\begin{array} { r } { \sum _ { t = 1 } ^ { \infty } \beta _ { t } \le \infty , \sum _ { t = 1 } ^ { \infty } \beta _ { t } ^ { 2 } \le } \end{array}$ $\infty$ . Then the clean loss of Aggregation Net can achieve $\| \nabla _ { \theta } L ^ { c } ( \hat { w } ( \theta _ { t } ) ) \| _ { 2 } ^ { 2 } \le \epsilon$ in $\mathcal { O } ( 1 / \epsilon ^ { 2 } )$ steps. More specifically,
+
+$$
+\operatorname* { m i n } _ { 0 \leq t \leq T } \| \nabla _ { \boldsymbol { \theta } } L ^ { c } ( \hat { w } ( \boldsymbol { \theta } _ { t } ) ) \| _ { 2 } ^ { 2 } \leq \mathcal { O } ( \frac { C } { \sqrt { T } } ) .
+$$
+
+Theorem 2 Under the conditions of Theorem $^ { l }$ , with the gradient of loss bounded by $\rho$ , then
+
+$$
+\operatorname* { l i m } _ { t \to \infty } \| \nabla _ { w _ { t } } L ^ { t r } ( w _ { t } , \theta _ { t + 1 } ) \| _ { 2 } ^ { 2 } = 0 .
+$$
+
+Algorithm 1: LPM. Line 2-12: label propagation; Line 13-22: label aggregation.   
+Data: $\overline { { \mathcal { D } , \mathcal { D } _ { t r a i n } , \mathcal { D } _ { c l e a n } } }$ , max epochs $T$ , LP iterations $K$ in every epoch, $A$ ,feature matrix   
+$\mathcal { X }$ ,GNNs feature extractor $f$ , Aggregation Network $g$ , expanding clean set for LP $\cdot$   
+Result: Robust GNNs parameters $w _ { T }$   
+1 Dc = Dclean   
+2 for $t = 0 , 1 , 2 , . . . , T - 1$ do   
+3 for $\forall v \in \mathcal { D }$ do $h _ { v } = f ( x _ { v } ; w _ { t } )$ ;   
+4 for (i, j) ∈ {1, 2, ..., n}2 do Wi,j = Ai,jd(hi,hj )+ε ;   
+5 $\left| \begin{array} { l } { \begin{array} { r l } { Y ^ { ( k + 1 ) } = D ^ { - 1 / 2 } W D ^ { - 1 / 2 } Y ^ { ( k ) } , y _ { j } ^ { ( k + 1 ) } = y _ { j } ^ { ( 0 ) } ( \forall \bmod { e } \ j \in \mathcal { D } _ { c } ) } \end{array} } \end{array} \right.$ $k = 0 , 1 , 2 , . . . , K - 1$   
+7 end   
+8 $\mathcal { D } _ { s e l e c t } = \mathcal { D } _ { l e f t } = \emptyset$ ;   
+9 for ∀ node $i \in \mathcal { D } _ { t r a i n }$ do   
+10 if onehot $( y _ { i } ^ { ( K ) } ) = y _ { i }$ do $\mathcal { D } _ { s e l e c t } =$ node $\{ i \} \cup \mathcal { D } _ { s e l e c t }$ ;   
+11 else do $\mathcal { D } _ { l e f t } = \mathrm { n o d }$ e $\{ i \} \cup \mathcal { D } _ { l e f t }$ ;   
+12 end   
+13 $-$   
+14 $w _ { t } \gets$ one-step optimization of $w _ { t }$ with the selected nodes $\mathcal { D } _ { s e l e c t }$ ;   
+15 for $\forall$ node $j \in \mathcal { D } _ { l e f t }$ do   
+16 $\hat { y } _ { j } = f ( x _ { j } ; w _ { t } )$ ;   
+17 $\bar { l _ { 1 } } = l o s s ( \hat { y } _ { j } , y _ { j } ) ; l _ { 2 } = l o s s ( \hat { y } _ { j } , \tilde { y } _ { j } ) ;$ ;   
+18 $\lambda _ { j } = g ( l _ { 1 } \parallel \bar { l } _ { 2 } ; \bar { \theta } _ { t } )$ ;   
+19 $\overline { { y } } _ { j } = \lambda _ { j } y _ { j } + ( 1 - \lambda _ { j } ) \widetilde { y } _ { j } , \lambda _ { j } \in [ 0 , 1 ] ; L _ { j } ^ { t r } ( w , \theta ) = l o s s ( \widehat { y } _ { j } ( w ) , \overline { { y } } _ { j } ( \theta ) ) ;$   
+20 end   
+21 $\begin{array} { r } { \hat { w } _ { t } ( \theta _ { t } ) = w _ { t } - \frac { \alpha } { | \mathcal { D } _ { l e f t } | } \sum _ { ( x _ { j } , y _ { j } ) \in \mathcal { D } _ { l e f t } } \nabla _ { w } L _ { j } ^ { t r } ( w , \theta _ { t } ) | _ { w _ { t } } ; } \end{array}$   
+22 $\begin{array} { r } { L ^ { c } ( \hat { w } _ { t } ( \boldsymbol { \theta } _ { t } ) ) = \frac { 1 } { | \mathcal { D } _ { c l e a n } | } \sum _ { ( \boldsymbol { x } _ { i } , \boldsymbol { y } _ { i } ) \in \mathcal { D } _ { c l e a n } } l o s s ( f ( \boldsymbol { x } _ { i } ; \boldsymbol { \hat { w } } _ { t } ( \boldsymbol { \theta } _ { t } ) ) , \boldsymbol { y } _ { i } ) . } \end{array}$ | P(xi,yi)∈Dclean l ;   
+23 $\theta _ { t + 1 } = \theta _ { t } - \beta \nabla _ { \theta } L ^ { c } ( \hat { w } ( \theta ) ) | _ { \theta _ { t } }$ ;   
+24 $\begin{array} { r } { w _ { t + 1 } = w _ { t } - \frac { \alpha } { | \mathscr { D } _ { l e f t } | } \sum _ { ( x _ { j } , y _ { j } ) \in \mathscr { D } _ { l e f t } } \nabla _ { w } L _ { j } ^ { t r } ( w ; \theta _ { t + 1 } ) | _ { w _ { t } } . } \end{array}$
+
+25 end
+
+# 4 EXPERIMENTS
+
+# 4.1 DATASETS AND IMPLEMENTATION DETAILS
+
+We validate our method on six benchmark datasets, namely citation networks (Sen et al., 2008) including Cora, Citeseer and Pubmed. Coauthor-Phy dataset (Shchur et al., 2018) is also utilized in our experiments, but the results are shown in Appendix A due to the limited space. Summary of the graph datasets mentioned above are shown in Table. 1. The Clothing1M (Xiao et al., 2015) and Webvision (Li et al., 2017a) dataset are utilized to validate the effectiveness of our method in real-world label noise settings. We take a $k \mathbf { N N }$ graph $k = 5$ ) as the graph structure so that GNNs can be applied in these two datasets, which follows previous work (Franceschi et al., 2019). More details about our preprocessing on Clothing1M and Webvision datasets can be seen in Appendix B.
+
+The experiments are conducted with two types of label noise: uniform noise and flip noise following previous works (Zhang et al., 2016a; Shu et al., 2019). The former means that the label of each sample is independently changed to a random class with probability $p$ , and the latter means that the label is independently flipped to a similar class with total probability $p$ . The ratio of training, validation, and test nodes are set as 4:4:2. Only nearly 25 nodes with clean labels in the validation set are provided as the clean set in each dataset and we ensure that each class has the same number of samples. For example, we use 8 clean samples per label class for Pubmed. GCN (Kipf & Welling, 2016) serves as the base classification network model in our experiments and it is trained using Adam (Kingma & Ba, 2014) with an initial learning rate 0.01 and a weight decay $5 \times 1 0 ^ { - 4 }$ , except that the weight decay equals to 0 in Clothing1M and Coauthor-Phy datasets.
+
+We compare LPM with multiple baselines using the same network architecture. These baselines are typical and some of them achieve state-of-the-arts performance on image datasets, which include:
+
+Table 1: Dataset statistics after removing self-loops and duplicate edges (Wang & Leskovec, 2020)   
+
+<table><tr><td></td><td>Cora</td><td>Citeseer</td><td>Pubmed</td><td>Coauthor-Phy</td></tr><tr><td>#nodes</td><td>2708</td><td>3327</td><td>19717</td><td>34493</td></tr><tr><td>#edges</td><td>5278</td><td>4552</td><td>44324</td><td>247962</td></tr><tr><td>#features</td><td>1433</td><td>3703</td><td>500</td><td>8415</td></tr><tr><td>#classes</td><td>7</td><td>6</td><td>3</td><td>5</td></tr><tr><td>#Intra-class edge rate</td><td>81.0%</td><td>73.6%</td><td>80.2%</td><td>93.1%</td></tr></table>
+
+Table 2: Comparison with baselines in test accuracy $( \% )$ on Cora and Citeseer with uniform noise ranging from $0 \%$ to $80 \%$ . Mean accuracy (std) over 5 repetitions are reported. The best and the second best results are highlighted in bold and italic bold respectively.   
+
+<table><tr><td>Datasets</td><td colspan="5">Cora</td><td colspan="5">Citeseer</td></tr><tr><td>Method/noise rate</td><td>0.0</td><td>0.2</td><td>0.4</td><td>0.6</td><td>0.8</td><td>0.0</td><td>0.2</td><td>0.4</td><td>0.6</td><td>0.8</td></tr><tr><td>Basemodel</td><td>87.84 (0.04)</td><td>85.92 (0.10)</td><td>82.42 (0.13)</td><td>75.77 (0.18)</td><td>56.32 (0.19)</td><td>77.67 (0.13)</td><td>76.06 (0.15)</td><td>72.97 (0.09)</td><td>67.98 (0.12)</td><td>55.26 (0.22)</td></tr><tr><td>GCN+FT</td><td>88.05 (0.06)</td><td>86.07 (0.13)</td><td>82.48 (0.14)</td><td>75.88 (0.15)</td><td>58.81(0.22)</td><td>77.86 (0.15)</td><td>76.24 (0.07)</td><td>73.42 (0.21)</td><td>68.13 (0.19)</td><td>56.12 (0.28)</td></tr><tr><td>L2RW</td><td>88.84 (0.19)</td><td>85.10 (0.21)</td><td>80.67 (0.22)</td><td>73.43 (0.42)</td><td>50.09 (0.37)</td><td>76.73 (0.20)</td><td>73.68 (0.14)</td><td>69.93 (0.29)</td><td>62.31(0.32)</td><td>46.55 (0.49)</td></tr><tr><td>Co-teaching plus + FT</td><td>86.76 (0.14)</td><td>83.03 (0.19)</td><td>71.68 (0.21)</td><td>50.05 (0.31)</td><td>36.39 (0.44)</td><td>76.28 (0.19)</td><td>75.49 (0.24)</td><td>72.71 (0.13)</td><td>66.63 (0.41)</td><td>56.27 (0.36)</td></tr><tr><td>MW-Nets</td><td>88.33 (0.16)</td><td>85.93 (0.22)</td><td>82.61 (0.45)</td><td>75.60 (0.41)</td><td>56.37 (0.51)</td><td>78.27 (0.12)</td><td>76.62 (0.14)</td><td>74.25 (0.21)</td><td>68.06 (0.25)</td><td>56.53 (0.45)</td></tr><tr><td>GCEloss+FT</td><td>87.87 (0.13)</td><td>85.10 (0.09)</td><td>82.89 (0.07)</td><td>76.16 (0.15)</td><td>60.43 (0.21)</td><td>78.01 (0.12)</td><td>76.54 (0.09)</td><td>74.06 (0.18)</td><td>69.18 (0.24)</td><td>58.48 (0.31)</td></tr><tr><td>APL+FT</td><td>87.68 (0.08)</td><td>86.26 (0.05)</td><td>82.01 (0.13)</td><td>74.49 (0.19)</td><td>58.72 (0.25)</td><td>76.54 (0.08)</td><td>74.32 (0.17)</td><td>71.77 (0.15)</td><td>66.78 (0.22)</td><td>56.08 (0.34)</td></tr><tr><td>Ours</td><td>88.75 (0.07)</td><td>87.46 (0.11)</td><td>83.95 (0.15)</td><td>79.66 (0.22)</td><td>63.38 (0.27)</td><td>78.12 (0.13)</td><td>77.07 (0.06)</td><td>75.19 (0.15)</td><td>70.05 (0.11)</td><td>61.71 (0.22)</td></tr></table>
+
+Base model, referring to the GCN that directly trained on noisy training nodes; Meta-learning based methods L2RW (Ren et al., 2018), MW-Nets (Shu et al., 2019); Typical and effective method Co-teaching plus (Yu et al., 2019); Robust loss function against label noise GCE loss (Zhang & Sabuncu, 2018) and APL (Ma et al., 2020); The most recent method based on co-training JoCoR (Wei et al., 2020). For those baselines that don’t need clean sets (Base model, Co-teaching plus, GCE loss, JoCoR and APL), we finetune (denoted by FT in this paper) them on the initial clean sets after the model was trained on training sets for a fair comparison. More experimental details about LPM and all baselines are available in the Appendix B.
+
+# 4.2 RESULTS
+
+Table. 2 shows the results on Cora and Citeseer with different levels of uniform noise ranging from $0 \%$ to $80 \%$ . Every experiment are repeated 5 times with different random seeds. Finally, we report the best test accuracy across all epochs averaged over 5 repetitions for each experiment. As can be seen in Table. 2, our method gets the best performance across all the datasets and all noise rates, except the second for $0 \%$ uniform noise rate. Our method performs even better when the labels are corrupted at high rate. Table. 3 shows the performance on Cora, Citeseer and Pubmed with different levels of flip noise ranging from $0 \%$ to $40 \%$ . It can be seen that our method also outperforms state-of-the-arts methods under flip noise across different noise rate, except that the second for $0 \%$ flip noise rate. Our method outperforms the corresponding second best method by a large margin when the noise rate is 0.4. As can be seen in Table. 4, our method can also perform better than other baselines in datasets with real-world label noise. We also experiment with Graph Attention Networks (Velickovic et al., 2017) as the feature extractor and classifier, the results shown in Appendix A demonstrate that our method can also perform well with other GNNs.
+
+Table 3: Comparison with baselines in test accuracy $( \% )$ on Cora , Citeseer and Pubmed with flip noise ranging from $0 \%$ to $40 \%$ . Mean accuracy (std) over 5 repetitions are reported. The best and the second best results are highlighted in bold and italic bold respectively.   
+
+<table><tr><td>Datasets</td><td colspan="3">Cora</td><td colspan="3">Citeseer</td><td colspan="3">Pubmed</td></tr><tr><td>Method/noise rate</td><td>0</td><td>0.2</td><td>0.4</td><td>0</td><td>0.2</td><td>0.4</td><td>0</td><td>0.2</td><td>0.4</td></tr><tr><td>Basemodel</td><td>87.84 (0.04)</td><td>81.64 (0.11)</td><td>61.12 (0.24)</td><td>77.67 (0.13)</td><td>75.91 (0.14)</td><td>52.67 (0.35)</td><td>86.18 (0.08)</td><td>85.30 (0.21)</td><td>74.21 (0.29)</td></tr><tr><td>GCN+FT</td><td>88.05 (0.06)</td><td>82.89 (0.14)</td><td>67.39 (0.42)</td><td>77.86 (0.15)</td><td>75.08 (0.22)</td><td>61.41 (0.23)</td><td>86.21 (0.09)</td><td>85.55 (0.24)</td><td>80.88 (0.32)</td></tr><tr><td>L2RW</td><td>88.84 (0.19)</td><td>80.90 (0.21)</td><td>59.00 (0.34)</td><td>76.73 (0.20)</td><td>71.85 (0.25)</td><td>50.04 (0.44)</td><td>86.34 (0.14)</td><td>84.54 (0.19)</td><td>76.97 (0.31)</td></tr><tr><td>Co-teaching plus+FT</td><td>86.76 (0.14)</td><td>81.37 (0.21)</td><td>53.00 (0.51)</td><td>76.28 (0.19)</td><td>74.66 (0.21)</td><td>60.59 (0.33)</td><td>85.59 (0.09)</td><td>84.61 (0.22)</td><td>73.99 (0.33)</td></tr><tr><td>MW-Nets</td><td>88.33 (0.16)</td><td>85.33 (0.23)</td><td>67.71 (0.43)</td><td>78.27 (0.12)</td><td>76.84 (0.19)</td><td>61.97 (0.33)</td><td>86.02 (0.07)</td><td>84.74 (0.17)</td><td>78.59 (0.28)</td></tr><tr><td>GCEloss+FT</td><td>87.87 (0.13)</td><td>83.21 (0.13)</td><td>67.80 (0.37)</td><td>78.01 (0.12)</td><td>76.36 (0.20)</td><td>63.66 (0.46)</td><td>86.15 (0.11)</td><td>85.47 (0.06)</td><td>80.03 (0.42)</td></tr><tr><td>APL+FT</td><td>87.68 (0.08)</td><td>81.09 (0.14)</td><td>70.07 (0.19)</td><td>76.54 (0.08)</td><td>73.38 (0.13)</td><td>60.81 (0.52)</td><td>86.16 (0.05)</td><td>85.52 (0.06)</td><td>70.08 (0.16)</td></tr><tr><td>Ours</td><td>88.75 (0.07)</td><td>86.95 (0.12)</td><td>78.97 (0.33)</td><td>78.12 (0.13)</td><td>76.39 (0.14)</td><td>69.71 (0.39)</td><td>86.48 (0.05)</td><td>85.58 (0.13)</td><td>83.15 (0.36)</td></tr></table>
+
+Table 4: Comparison with baselines in test accuracy $( \% )$ on Clothing1M and Webvision. Mean accuracy $\pm$ std) over 5 repetitions are reported. The best is highlighted in bold.   
+
+<table><tr><td>Methods</td><td>Basemodel</td><td>GCN+FT</td><td>L2RW</td><td>MW-Nets</td><td>GCEloss+FT</td><td>JoCoR+FT</td><td>Ours</td></tr><tr><td>Clothing1M</td><td>35.83±0.03</td><td>38.05±0.13</td><td>53.5±0.08</td><td>54.15±0.23</td><td>56.9±0.08</td><td>56.3±0.12</td><td>57.35±0.11</td></tr><tr><td>Webvision</td><td>32.43±0.05</td><td>34.58±0.08</td><td>50.12±0.16</td><td>52.42±0.25</td><td>53.45±0.13</td><td>54.12±0.22</td><td>55.43±0.17</td></tr></table>
+
+![](images/08f88f4348654662facdd2e5ddebef946582e909d05aae0475024c1ae7459de1.jpg)  
+Figure 3: Comparsion of the true-labeled samples rate in $\mathcal { D } _ { t r a i n }$ and $\mathcal { D } _ { s e l e c t }$ in various datasets.
+
+Table 5: The performance of LPM without label aggregation and LPM with random $\lambda$ in Citeseer.   
+
+<table><tr><td>Noise type</td><td colspan="5">Uniform noise</td><td colspan="2">Flip noise</td></tr><tr><td>Method/noise rate</td><td>0</td><td>0.2</td><td>0.4</td><td>0.6</td><td>0.8</td><td>0.2</td><td>0.4</td></tr><tr><td>Ours w/o label aggregation</td><td>72.07</td><td>68.36</td><td>65.69</td><td>62.16</td><td>54.39</td><td>69.26</td><td>63.14</td></tr><tr><td>Ours with random 入</td><td>76.88</td><td>75.08</td><td>72.07</td><td>68.28</td><td>57.40</td><td>74.89</td><td>68.30</td></tr><tr><td> Ours with tuned 入</td><td>77.22</td><td>76.31</td><td>73.55</td><td>69.17</td><td>58.54</td><td>75.11</td><td>68.72</td></tr><tr><td>Ours</td><td>78.12</td><td>77.07</td><td>75.19</td><td>70.05</td><td>61.71</td><td>76.39</td><td>69.71</td></tr></table>
+
+# 4.3 ANALYSIS OF THE NECESSITY AND EFFECTIVENESS OF DIFFERENT PARTS
+
+We design five experiments to validate the necessity and effectiveness of different components of our algorithm. Firstly, we compare the ratio of truelabeled nodes in $\mathcal { D } _ { s e l e c t }$ with $\mathcal { D } _ { t r a i n }$ in the last epoch to validate the effectiveness of LP. Figure. 3 shows the ratio of true-labeled nodes in $\mathcal { D } _ { s e l e c t }$ in the last epoch and $\mathcal { D } _ { t r a i n }$ under uniform noise on various datasets. It can be found that nearly all the nodes selected by LP are true-labeled even if most training nodes are mislabeled, which demonstrates the great ability of LP to select true-labeled nodes from noisy training nodes. Secondly, we remove the label aggregation in LPM to validate its necessity and the result shows that the performance of our method become much worse without label aggregation. It is necessary to mine the potential information from the left noisy training nodes after LP selection. Besides, we validate the effectiveness by replacing the learned aggregation coefficients $\lambda$ with random numbers between 0 and 1. It is obvious that the aggregation coefficients $\lambda$ optimized by meta learning outperform random $\lambda$ . Also, we assign the percentage of clean nodes of each label class as $\cdot$ (tuned) for comparison. These validate the effectiveness of the meta-learning based label aggregation. The results of above two experiments are shown in Table. 5. We denote the average of $\cdot$ of clean nodes and noisy nodes in $\mathscr { D } _ { l e f t }$ as $\lambda _ { c l e a n }$ and $\cdot$ respectively, $-$ . We plot the variation of $\cdot$ during training stage in Figure. 4. It can be observed that $\lambda _ { c l e a n } > \lambda _ { n o i s e }$ across the training stage and the margin between $\lambda _ { c l e a n }$ and $\cdot$ grows larger with the training process, which suggests that $\lambda$ optimized by our method is valid.
+
+![](images/03d0ba0eeaf7908606d67d6994c9e324d3478aaaa12f68fe51a7639ae44eb405.jpg)  
+Figure 4: $\Delta \lambda$ varies during the training stage on Cora with various uniform noise rate.
+
+![](images/018150531e5b3cc45a63032fb743dfbc7c5e2fde9850f52237b079339ae5ce1d.jpg)  
+Figure 5: Test accuracy on Cora and Citeseer across various flip noise rate.
+
+# 4.4 IMPACT OF FINETUNING AND NOISE RATE
+
+We would like to investigate how our baselines can perform without finetuning. As can be seen in Figure. 5, the performance of the baselines will degenerate relatively significantly without finetuning across different noise rate. This illustrates that some baselines (without finetuning) that are designed for image datasets may perform relatively poor on graph-structured data and this motivates our work which trains GNNs robustly utilizing the structure information of graph data. Besides, We can also observe that our method only drops nearly $9 \%$ when the flip noise rate increased from $0 \%$ to $40 \%$ , whereas the baseline has dropped nearly $2 0 \% - 3 0 \%$ , which illustrates that our method is more robust, especially at high noise rate. At $0 \%$ noise, our method only slightly underperforms reweights besed methods. This is reasonable because the original labels are all correct but our method will inevitably perturb a few clean labels while the re-weights based methods will not.
+
+# 4.5 SIZE OF THE CLEAN SET
+
+We try to strike a balance and understand when finetuning will be effective. As can be seen in Figure. 6, our method can also perform better even if the size of clean set is extremely small. The overall test accuracy does not grow much when the size of clean set is large enough. Besides, the test accuracy of baselines with fintuning will increase significantly when the size of clean set grows larger. This suggests that finetuning will be valid when the size of clean set grows larger because GNNs can achieve good performance with relatively less samples (Kipf & Welling, 2016; Velickovi ˇ c et al., 2017). From this perspective, our method can also serve as complementary for ´ finetuning based methods when the size of clean set is large enough.
+
+![](images/8e987b26205d135963820007bc9f624c5916d6a9b90e8d4260014e400b707c59.jpg)  
+Figure 6: Test accuracy on Cora and Citeseer across various size of clean set.
+
+# 5 CONCLUSION AND FUTURE WORK
+
+In this work, we proposed a robust framwork for GNNs against label noise. This is the first method that specially designed for label noise problem existing in utilizing GNNs to classify graph nodes and it outperforms state-of-the-arts methods in graph-structured data, which may serve as the beginning for future research towards robust GNNs against label noise. As a future work, we may design an inductive robust method. Besides, better methods that don’t need clean sets are also the goals of us.
+
+# REFERENCES
+
+Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, Brendan Shillingford, and Nando De Freitas. Learning to learn by gradient descent by gradient descent. In Advances in neural information processing systems, pp. 3981–3989, 2016.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. arXiv preprint arXiv:1703.03400, 2017.
+
+Luca Franceschi, Mathias Niepert, Massimiliano Pontil, and Xiao He. Learning discrete structures for graph neural networks. arXiv preprint arXiv:1903.11960, 2019.
+
+Chen Gong, Dacheng Tao, Wei Liu, Liu Liu, and Jie Yang. Label propagation via teaching-tolearn and learning-to-teach. IEEE transactions on neural networks and learning systems, 28(6): 1452–1465, 2016.
+
+Chen Gong, Hengmin Zhang, Jian Yang, and Dacheng Tao. Learning with inadequate and incorrect supervision. In 2017 IEEE International Conference on Data Mining (ICDM), pp. 889–894. IEEE, 2017.
+
+Edward Grefenstette, Brandon Amos, Denis Yarats, Phu Mon Htut, Artem Molchanov, Franziska Meier, Douwe Kiela, Kyunghyun Cho, and Soumith Chintala. Generalized inner loop metalearning. arXiv preprint arXiv:1910.01727, 2019.
+
+Bo Han, Quanming Yao, Xingrui Yu, Gang Niu, Miao Xu, Weihua Hu, Ivor Tsang, and Masashi Sugiyama. Co-teaching: Robust training of deep neural networks with extremely noisy labels. In Advances in neural information processing systems, pp. 8527–8537, 2018.
+
+Yifan Hou, Jian Zhang, James Cheng, Kaili Ma, Richard TB Ma, Hongzhi Chen, and Ming-Chang Yang. Measuring and improving the use of graph information in graph neural networks. In International Conference on Learning Representations, 2019.
+
+Ahmet Iscen, Giorgos Tolias, Yannis Avrithis, and Ondrej Chum. Label propagation for deep semisupervised learning. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 5070–5079, 2019.
+
+Simon Jenni and Paolo Favaro. Deep bilevel learning. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 618–633, 2018.
+
+Masayuki Karasuyama and Hiroshi Mamitsuka. Manifold-based similarity adaptation for label propagation. In Advances in neural information processing systems, pp. 1547–1555, 2013.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.
+
+M Pawan Kumar, Benjamin Packer, and Daphne Koller. Self-paced learning for latent variable models. In Advances in neural information processing systems, pp. 1189–1197, 2010.
+
+Junnan Li, Yongkang Wong, Qi Zhao, and Mohan S Kankanhalli. Learning to learn from noisy labeled data. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5051–5059, 2019.
+
+Wen Li, Limin Wang, Wei Li, Eirikur Agustsson, and Luc Van Gool. Webvision database: Visual learning and understanding from web data. arXiv preprint arXiv:1708.02862, 2017a.
+
+Yuncheng Li, Jianchao Yang, Yale Song, Liangliang Cao, Jiebo Luo, and Li-Jia Li. Learning from noisy labels with distillation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1910–1918, 2017b.
+
+Yanbin Liu, Juho Lee, Minseop Park, Saehoon Kim, Eunho Yang, Sung Ju Hwang, and Yi Yang. Learning to propagate labels: Transductive propagation network for few-shot learning. arXiv preprint arXiv:1805.10002, 2018.
+
+Xingjun Ma, Hanxun Huang, Yisen Wang, Simone Romano, Sarah Erfani, and James Bailey. Normalized loss functions for deep learning with noisy labels. arXiv preprint arXiv:2006.13554, 2020.
+
+Hyoungseob Park, Minki Jeong, Youngeun Kim, and Changick Kim. Self-training of graph neural networks using similarity reference for robust training with noisy labels. In 2020 IEEE International Conference on Image Processing (ICIP), pp. 1951–1955. IEEE, 2020.
+
+Mengye Ren, Wenyuan Zeng, Bin Yang, and Raquel Urtasun. Learning to reweight examples for robust deep learning. arXiv preprint arXiv:1803.09050, 2018.
+
+Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3):93–93, 2008.
+
+Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Gunnemann. Pitfalls ¨ of graph neural network evaluation. arXiv preprint arXiv:1811.05868, 2018.
+
+Jun Shu, Qi Xie, Lixuan Yi, Qian Zhao, Sanping Zhou, Zongben Xu, and Deyu Meng. Meta-weightnet: Learning an explicit mapping for sample weighting. In Advances in Neural Information Processing Systems, pp. 1919–1930, 2019.
+
+Petar Velickovic, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. Graph attention networks. arXiv: Machine Learning, 2017.
+
+Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017.
+
+Fei Wang and Changshui Zhang. Label propagation through linear neighborhoods. IEEE Transactions on Knowledge and Data Engineering, 20(1):55–67, 2007.
+
+Hongwei Wang and Jure Leskovec. Unifying graph convolutional neural networks and label propagation. arXiv preprint arXiv:2002.06755, 2020.
+
+Hongxin Wei, Lei Feng, Xiangyu Chen, and Bo An. Combating noisy labels by agreement: A joint training method with co-regularization. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.
+
+Tong Xiao, Tian Xia, Yi Yang, Chang Huang, and Xiaogang Wang. Learning from massive noisy labeled data for image classification. pp. 2691–2699, 2015.
+
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? arXiv preprint arXiv:1810.00826, 2018.
+
+Xingrui Yu, Bo Han, Jiangchao Yao, Gang Niu, Ivor W Tsang, and Masashi Sugiyama. How does disagreement help generalization against label corruption? arXiv preprint arXiv:1901.04215, 2019.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016a.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016b.
+
+Huan Zhang, Zhao Zhang, Mingbo Zhao, Qiaolin Ye, Min Zhang, and Meng Wang. Robust triplematrix-recovery-based auto-weighted label propagation for classification. IEEE Transactions on Neural Networks and Learning Systems, 2020.
+
+Zhilu Zhang and Mert Sabuncu. Generalized cross entropy loss for training deep neural networks with noisy labels. In Advances in neural information processing systems, pp. 8778–8788, 2018.
+
+Dengyong Zhou, Olivier Bousquet, Thomas N Lal, Jason Weston, and Bernhard Scholkopf. Learn- ¨ ing with local and global consistency. In Advances in neural information processing systems, pp. 321–328, 2004.
+
+Xiaojin Zhu, John Lafferty, and Ronald Rosenfeld. Semi-supervised learning with graphs. PhD thesis, Carnegie Mellon University, language technologies institute, school of . . . , 2005.
+
+# A APPENDIX : ADDITIONAL EXPERIMENT RESULTS
+
+Table A.6: Comparison with baselines in test accuracy $( \% )$ on Cora and Pubmed with flip noise ranging from $0 \%$ to $40 \%$ and Graph Attention Networks. The best result are highlighted in bold.   
+
+<table><tr><td>Datasets</td><td colspan="3">Cora</td><td colspan="3">Pubmed</td></tr><tr><td>Methods/Noise rate</td><td>0</td><td>0.2</td><td>0.4</td><td>0</td><td>0.2</td><td>0.4</td></tr><tr><td>GAT</td><td>89.85</td><td>84.13</td><td>67.10</td><td>85.55</td><td>84.57</td><td>74.11</td></tr><tr><td>GAT+FT</td><td>89.85</td><td>84.50</td><td>73.12</td><td>85.55</td><td>84.57</td><td>80.55</td></tr><tr><td>MW-Nets</td><td>87.52</td><td>84.26</td><td>69.99</td><td>85.64</td><td>84.5</td><td>75.82</td></tr><tr><td>Co-teaching plus+FT</td><td>88.56</td><td>85.42</td><td>74.94</td><td>85.56</td><td>84.48</td><td>82.40</td></tr><tr><td>GCEloss+FT</td><td>89.98</td><td>84.38</td><td>74.23</td><td>85.45</td><td>84.54</td><td>80.65</td></tr><tr><td>JoCoR+FT</td><td>90.16</td><td>85.00</td><td>73.74</td><td>85.47</td><td>84.58</td><td>80.95</td></tr><tr><td>Ours</td><td>89.92</td><td>87.20</td><td>75.65</td><td>85.72</td><td>84.62</td><td>83.00</td></tr></table>
+
+Table A.7: Comparison with baselines in test accuracy $( \% )$ on Coauthor-Phy with flip noise ranging from $0 \%$ to $40 \%$ . The best result are highlighted in bold.   
+
+<table><tr><td>Method/Noise rate</td><td>0.0</td><td>0.1</td><td>0.2</td><td>0.3</td><td>0.4</td></tr><tr><td>Basemodel</td><td>96.92</td><td>96.32</td><td>95.57</td><td>94.91</td><td>86.25</td></tr><tr><td>GCN+FT</td><td>96.96</td><td>96.41</td><td>95.54</td><td>94.46</td><td>92.25</td></tr><tr><td>Co-teaching plus+FT</td><td>96.45</td><td>96.39</td><td>96.10</td><td>95.27</td><td>92.79</td></tr><tr><td>MW-Nets</td><td>96.56</td><td>96.24</td><td>95.62</td><td>95.56</td><td>89.25</td></tr><tr><td>GCEloss+FT</td><td>96.99</td><td>96.58</td><td>95.96</td><td>94.77</td><td>93.64</td></tr><tr><td>JoCoR+FT</td><td>96.83</td><td>96.59</td><td>96.07</td><td>94.95</td><td>94.11</td></tr><tr><td>Ours</td><td>96.75</td><td>96.71</td><td>96.49</td><td>96.14</td><td>95.14</td></tr></table>
+
+We also take Graph Attention Networks (GAT) as the feature extractor and classifier and the results shown in Table. A.6 validate that our method can also perform well with various GNNs. Besides, LPM can also perform better than other baselines in larger graph dataset Coauthor-Phy, the results can be seen in Table. A.7. We also demonstrate confusion matrices of Basemodel and LPM in Figure. A.4, which visually show that our method can improve the robustness against label noise of GNNs by a large margin.
+
+# B APPENDIX : ADDITIONAL DETAILS OF OUR EXPERIMENTS
+
+Original Clothing1M and Webvision datasets are all large-scale datasets with real-world label noise. We randomly choose 5000 images in 10 classes from original datasets and every image serves as a node in the graph, a kNN graph $\left( \mathrm { k } \mathrm { = } 5 \right)$ is treated as the graph structure so that GNNs can be applied in Clothing1M datasets. This setting is similar to some previous works which also aim to apply GNNs in datasets without graph structure. ResNet-50 with ImageNet pretrained weights is utilized by us to extract feature vectors for all the images.
+
+Table. A.8 shows the different hyper-parameters in LPM experiments for different datasets. In all the experiments, 25 true-labeled nodes are utilized as the initial clean sets or as the samples for finetuning and the total epoch of all the experiments is 300. In Co-teaching plus experiment, the initial epoch is 270, the forget rate is 0.1 and 5 epochs for linear drop rate ,the exponent of the forget rate is 1. For MW-Nets, the dimension of the meta net’s middle layer is 100 and the learning rate is $5 \times 1 0 ^ { - 3 }$ . $q$ for GCEloss is 0.1. The combination of Normalized Focal Loss and Mean Absolute Error is utilized in APL experiments, the weight of Normalized Focal Loss is 0.1 and the weight of Mean Absolute Error is 10. For JoCoR experiments, the epochs for linear drop rate is 5 and the exponent of the forget rate is 2. The balance coefficient between conventional supervised learning loss and contrastive loss is 0.01. The learning rate and weight decay of Graph Attention Networks are 0.01 and $5 \times 1 0 ^ { - 4 }$ . The dimension of hidden layer of GAT is 16 and the number of head attentions is 8. The alpha of the leaky relu is 0.2 and the dropout rate is 0.5. Throughout this work we implemented gradient based meta-learning algorithms in PyTorch using the Higher library (Grefenstette et al., 2019).
+
+Table A.8: The hyper-parameters of LPM in different datasets.   
+
+<table><tr><td></td><td>Cora</td><td>Citeseer</td><td>Pubmed</td><td>Coauthor-Phy</td><td>Clothing1M</td></tr><tr><td>Aggregation Net&#x27;s learning rate</td><td>1×10-4</td><td>1×10-4</td><td>1×10-3</td><td>1×10-3</td><td>1×10-3</td></tr><tr><td>Aggregation Net&#x27;s mid-dimension</td><td>64</td><td>100</td><td>100</td><td>64</td><td>50</td></tr><tr><td>Aggregation Net&#x27;s weight decay</td><td>1×10-4</td><td>1×10-4</td><td>1×10-4</td><td>1×10-4</td><td>1×10-4</td></tr><tr><td>LPA iterations</td><td>50</td><td>50</td><td>50</td><td>50</td><td>50</td></tr></table>
+
+![](images/c0bf9ddecf3cf4ad60d9d9ff6ece4751d478fb438d0d72bc491040f95d3ac0c3.jpg)  
+Figure A.4: Confusion matrices of Basemodel and LPM on various datasets under $40 \%$ flip noise. Figure. 4(a)-4(c) are the results of Basemodel. Figure. 4(d)-4(f) are the results of LPM.
+
+# C APPENDIX : CONVERGENCE OF LPM
+
+Our proof of the convergence of LPM mainly follow some previous works (Ren et al., 2018; Shu et al., 2019) that utilize meta-learning to reweight noisy training samples. As is illustrated in some previous works (Zhou et al., 2004; Zhu et al., 2005), LPA will converge to a fixed point. Namely, $\mathcal { D } _ { s e l e c t }$ and $\mathcal { D } _ { l e f t }$ will converge to fixed sets. In our proof, the final $\mid \mathcal { D } _ { l e f t } \mid$ and final $\mid \mathcal { D } _ { c l e a n } \mid$ are denoted with $n$ and $m$ for easier illustration. Loss function loss is denoted by $l$ in this proof. Here we first rewrite the forward and backward equations as follows:
+
+$$
+\begin{array} { c } { { \displaystyle \hat { y } _ { j } = f ( x _ { j } ; w _ { t } ) = y _ { j } ( w ) \vert _ { w _ { t } } } } \\ { { \lambda _ { j } = g ( l ( y _ { j } , \hat { y } _ { j } ) \parallel l ( \tilde { y } _ { j } , \hat { y } _ { j } ) ; \theta _ { t } ) = \lambda _ { j } ( \theta ; w _ { t } ) \vert _ { \theta _ { t } } } } \\ { { { } } } \\ { { { \cal L } ^ { t r } ( w _ { t } ; \theta _ { t } ) = \displaystyle \frac { 1 } { n } \sum _ { j = 1 } ^ { n } l ( \lambda _ { j } y _ { j } + ( 1 - \lambda _ { j } ) \tilde { y } _ { j } , \hat { y } _ { j } ) } } \\ { { \hat { w } _ { t } ( \theta _ { t } ) = w _ { t } - \alpha \nabla _ { w } L ^ { c } ( w ; \theta _ { t } ) \vert _ { w _ { t } } } } \end{array}
+$$
+
+$$
+\begin{array} { c } { \displaystyle \hat { y } _ { i } = f ( \boldsymbol { x } _ { i } ; \hat { \boldsymbol { w } } _ { t } ) = y _ { i } ( \hat { \boldsymbol { w } } ; \boldsymbol { x } _ { i } ) \vert _ { \hat { \boldsymbol { w } } _ { t } } } \\ { \displaystyle L ^ { c } ( \hat { \boldsymbol { w } } ) \vert _ { \hat { \boldsymbol { w } } _ { t } } = \frac { 1 } { m } \sum _ { i = 1 } ^ { m } L _ { i } ^ { c } ( \hat { \boldsymbol { w } } ) \vert _ { \hat { \boldsymbol { w } } _ { t } } = \frac { 1 } { m } \sum _ { i = 1 } ^ { m } L _ { i } ^ { c } ( \hat { w } _ { t } ( \boldsymbol { \theta } ) ) \vert _ { \theta _ { t } } = \frac { 1 } { m } \sum _ { i = 1 } ^ { m } l ( y _ { i } , \hat { y } _ { i } ) } \\ { \displaystyle \theta _ { t + 1 } = \theta _ { t } - \beta \nabla _ { \boldsymbol { \theta } } L ^ { c } ( \hat { w } ( \boldsymbol { \theta } ) ) \vert _ { \theta _ { t } } } \\ { \displaystyle w _ { t + 1 } = w _ { t } - \alpha \nabla _ { \boldsymbol { w } } L ^ { t r } ( w ; \theta _ { t + 1 } ) \vert _ { w _ { t } } } \end{array}
+$$
+
+$( x _ { j } , y _ { j } )$ is node from the final left training set $\mathcal { D } _ { l e f t }$
+
+$( x _ { i } , y _ { i } )$ is node from the final clean set $\mathcal { D } _ { c l e a n }$ ;
+
+$f$ is the GCN for classification with its weights $w$ ;   
+$g$ is the Aggregation Net whose input are the nodes from clean set with its weights $\theta$ ;   
+$L ^ { c }$ is the loss on clean sets. $L ^ { t r }$ is the final training loss.
+
+$l ( y , \hat { y } )$ is the loss (such as Cross Entropy) which satisfies linearity given by
+
+$$
+l ( \lambda y _ { 1 } + ( 1 - \lambda ) y _ { 2 } , \hat { y } ) = \lambda l ( y _ { 1 } , \hat { y } ) + ( 1 - \lambda ) l ( y _ { 2 } , \hat { y } ) .
+$$
+
+# Derivation of the equation of updating the weights in Aggregation Net
+
+$$
+\frac { 1 } { m } \sum _ { i = 1 } ^ { m } \nabla _ { \theta } L _ { i } ^ { c } ( \hat { w } ( \theta ) ) | _ { \theta _ { t } } = \frac { 1 } { m } \sum _ { i = 1 } ^ { m } \frac { \partial L _ { i } ^ { c } ( \hat { w } ) } { \partial \hat { w } } | _ { \hat { w } _ { t } } \sum _ { j = 1 } ^ { n } \frac { \partial \hat { w } _ { t } ( \theta ) } { \partial \lambda _ { j } } | _ { \theta _ { t } } \frac { \partial \lambda _ { j } ( \theta ; w _ { t } ) } { \partial \theta } | _ { \theta _ { t } } .
+$$
+
+According to Equation (20)
+
+$$
+\begin{array} { l } { \displaystyle \dot { \varpi } _ { t } ( \theta ) | _ { \theta _ { t } } = w _ { t } - \alpha \nabla _ { w _ { t } } \frac { 1 } { n _ { j = 1 } ^ { n } } { l ( \lambda _ { j } y _ { j } + ( 1 - \lambda _ { j } ) \tilde { y } _ { j } , \hat { y } _ { j } ) } } \\ { \displaystyle \frac { \partial \hat { w } _ { t } ( \theta ) } { \partial \lambda _ { j } } | _ { \theta _ { t } } = - \frac { \alpha } { n } \nabla _ { w _ { t } } \frac { \partial ( l _ { \lambda j } y _ { j } + ( 1 - \lambda _ { j } ) \tilde { y } _ { j } , \hat { y } _ { j } ) } { \partial \lambda _ { j } } | _ { \theta _ { t } } } \\ { \displaystyle \frac { \partial \hat { w } _ { t } ( \theta ) } { \partial \lambda _ { j } } | _ { \theta _ { t } } = - \frac { \alpha } { n } \nabla _ { w _ { t } } \frac { \partial [ \lambda _ { j } l ( y _ { j } , \hat { y } _ { j } ) + ( 1 - \lambda _ { j } ) l ( \tilde { y } _ { j } , \hat { y } _ { j } ) ] } { \partial \lambda _ { j } } | _ { \theta _ { t } } } \\ { \displaystyle \frac { \partial \hat { w } _ { t } ( \theta ) } { \partial \lambda _ { j } } | _ { \theta _ { t } } = - \frac { \alpha } { n } \nabla _ { w _ { t } } ( l ( y _ { j } , \hat { y } _ { j } ) - l ( \tilde { y } _ { j } , \hat { y } _ { j } ) ) | _ { \theta _ { t } } } \\ { \displaystyle \frac { \partial \hat { w } _ { t } ( \theta ) } { \partial \lambda _ { j } } | _ { \theta _ { t } } = - \frac { \alpha } { n } \frac { \partial ( l ( y _ { j } , \hat { y } _ { j } ) - l ( \tilde { y } _ { j } , \hat { y } _ { j } ) ) } { \partial w _ { t } } | _ { w _ { t } } } \end{array}
+$$
+
+Therefore, Equation (25) can be written as
+
+$$
+\begin{array} { r l } & { \frac { 1 } { m } \displaystyle \sum _ { i = 1 } ^ { m } \nabla _ { \theta } L _ { i } ^ { c } ( \hat { w } ( \theta ) ) | _ { \theta _ { t } } } \\ & { = - \frac { \alpha } { m } \displaystyle \sum _ { i = 1 } ^ { m } \frac { \partial L _ { i } ^ { c } ( \hat { w } ( \theta ) ) } { \partial \hat { w } } | _ { \hat { w } _ { i } } \sum _ { j = 1 } ^ { n } \frac { \partial \left( l ( y _ { j } , \hat { y } _ { j } ) - l ( \hat { y } _ { j } , \hat { y } _ { j } ) \right) } { \partial w _ { t } } | _ { w _ { t } } \frac { \partial \lambda _ { j } \left( \theta ; w _ { t } \right) } { \partial \theta } | _ { \theta _ { t } } } \\ & { = - \frac { \alpha } { n } \displaystyle \sum _ { j = 1 } ^ { n } ( \frac { 1 } { m } \displaystyle \sum _ { i = 1 } ^ { m } \frac { \partial L _ { i } ^ { c } ( \hat { w } ( \theta ) ) } { \partial \hat { w } } | _ { \hat { w } _ { i } } \frac { \partial \left( l ( y _ { j } , \hat { y } _ { j } ) - l ( \hat { y } _ { j } , \hat { y } _ { j } ) \right) } { \partial \theta } | _ { w _ { t } } \frac { \partial \lambda _ { j } \left( \theta ; w _ { t } \right) } { \partial \theta } | _ { \theta _ { t } } } \\ & { = - \frac { \alpha } { n } \displaystyle \sum _ { j = 1 } ^ { n } ( \frac { 1 } { m } \displaystyle \sum _ { i = 1 } ^ { m } G _ { i j } ) \frac { \partial \lambda _ { j } \left( \theta ; w _ { t } \right) } { \partial \theta } | _ { \theta _ { t } } \mu _ { \epsilon } } \\ & { + \frac { \partial L _ { i } ^ { c } ( \hat { w } ) } { \partial \theta } | _ { \hat { w } _ { i } } \frac { \partial \left( l ( y _ { j } , \hat { y } _ { j } ) - l ( \hat { y } _ { j } , \hat { y } _ { j } ) \right) } { \partial \theta } | _ { \theta _ { t } } . } \end{array}
+$$
+
+where
+
+Lemma 1. Suppose the loss function $l$ is $\mathrm { L }$ -Lipschitz smooth, and $\lambda ( \cdot )$ is differential with a $\delta$ -bounded gradient, twice differential with its Hessian bounded by $\boldsymbol { B }$ with respcet to $\theta$ , and the loss function $l ( \cdot , \cdot )$ have $\rho$ -bounded gradients with respect to the parameter $w$ . Then the gradient of $w$ with respect to $L _ { i } ^ { c } ( \hat { w } )$ is Lipschitz continuous.
+
+Proof. The supposition is equivalent to the following inequalities,
+
+$$
+\| \nabla _ { \hat { w } } L ^ { c } ( \hat { w } ) | _ { w _ { 1 } } - \nabla _ { \hat { w } } L ^ { c } ( \hat { w } ) | _ { w _ { 2 } } \| \leq L \| w _ { 1 } - w _ { 2 } \| ,
+$$
+
+for any $w _ { 1 } , w _ { 2 }$ ;
+
+$$
+\begin{array} { r l r } & { } & { \| \nabla _ { \theta } \lambda ( \theta ; w _ { t } ) \| \le \rho ; } \\ & { } & { \| \nabla _ { \theta ^ { 2 } } ^ { 2 } \lambda ( \theta ; w _ { t } ) \| \le \mathcal B ; } \\ & { } & { \| \nabla _ { w } l ( y _ { i } , \hat { y } _ { i } ( ( \hat { w } _ { t } ( w ) ; x _ { i } ) ) ) \| \le \delta . } \end{array}
+$$
+
+The gradient of $\theta$ with respect to loss on clean set reads
+
+$$
+\begin{array} { l } { { \displaystyle \nabla _ { \theta } L _ { i } ^ { c } ( \hat { w } ( \theta ) ) \big | _ { \theta _ { t } } } } \\ { { \displaystyle = - \frac { \alpha } { n } \sum _ { j = 1 } ^ { n } \frac { \partial L _ { i } ^ { c } ( \hat { w } ) } { \partial \hat { w } } \vert _ { \hat { w } _ { t } } ^ { T } \frac { \partial ( l ( y _ { j } , \hat { y } _ { j } ) - l ( \tilde { y } _ { j } , \hat { y } _ { j } ) ) } { \partial { w _ { t } } } \vert _ { w _ { t } } \frac { \partial \lambda _ { j } ( \theta ; w _ { t } ) } { \partial \theta } \vert _ { \theta _ { t } } } } \\ { { \displaystyle = - \frac { \alpha } { n } \sum _ { j = 1 } ^ { n } G _ { i j } \frac { \partial \lambda _ { j } ( \theta ; w _ { t } ) } { \partial \theta } \vert _ { \theta _ { t } } } } \end{array}
+$$
+
+Taking the gradient of $\theta$ in both sides of the equation, we have
+
+$$
+\nabla _ { \theta ^ { 2 } } ^ { 2 } L _ { i } ^ { c } ( \hat { w } ( \theta ) ) | _ { \theta _ { t } } = - \frac { \alpha } { n } \sum _ { j = 1 } ^ { n } ( \frac { \partial G _ { i j } } { \partial \theta } | _ { \theta _ { t } } \frac { \partial \lambda _ { j } ( \theta ; w _ { t } ) } { \partial \theta } | _ { \theta _ { t } } + ( G _ { i j } ) \frac { \partial ^ { 2 } \lambda _ { j } ( \theta ; w _ { t } ) } { \partial \theta ^ { 2 } } | _ { \theta _ { t } } ) .
+$$
+
+For the first term in summation,
+
+$$
+\begin{array} { r l } & { \quad \| \frac { \partial G _ { i j } } { \partial \vartheta } | _ { \kappa _ { i } } \frac { \partial \lambda _ { j } ( \theta ; w _ { i } ) } { \partial \vartheta } | _ { \kappa _ { i } } \| } \\ & { \quad \le \delta \| \frac { \partial } { \partial \tilde { w } } ( \frac { \partial L _ { \epsilon } ^ { \epsilon } ( \tilde { w } ) } { \partial \vartheta } | _ { \kappa _ { i } } ) | _ { \kappa _ { i } } ^ { T } \frac { \partial ( l ( y _ { j } , \hat { y } _ { j } ) - l ( \tilde { y } _ { j } , \hat { y } _ { j } ) ) } { \partial w _ { k } } | _ { w _ { k } } \| } \\ & { \quad \le \delta \| \frac { \partial } { \partial \tilde { w } } ( - \frac { \alpha } { n } \sum _ { k = 1 } ^ { n } \frac { \partial L _ { \epsilon } ^ { \epsilon } ( \tilde { w } ) } { \partial \tilde { w } } | _ { \kappa _ { i } } ^ { T } \frac { \partial ( l ( y _ { k } , \hat { y } _ { k } ) - l ( \tilde { y } _ { k } , \hat { y } _ { k } ) ) } { \partial w _ { k } } | _ { w _ { k } } \frac { \partial \lambda _ { j } ( \theta ; w _ { k } ) } { \partial \theta } | _ { \kappa _ { i } } ) | _ { \tilde { w } _ { k } } ^ { T } \frac { \partial ( l ( y _ { j } , \hat { y } _ { j } ) - l ( \tilde { y } _ { j } , \hat { y } _ { j } ) ) } { \partial w _ { \ell } } | _ { w _ { k } } , } \\ &  \quad \le \delta \| ( - \frac { \alpha } { n } \sum _ { k = 1 } ^ { n } \frac { \partial ^ { 2 } L _ { \epsilon } ^ { \epsilon } ( \tilde { w } ) } { \partial \tilde { w } ^ { 2 } } | _ { \kappa _ { i } } ^ { T } \frac { \partial ( l ( y _ { k } , \hat { y } _ { k } ) - l ( \tilde { y } _ { k } , \hat { y } _ { k } ) ) } { \partial w _ { \ell } } | _ { w _ { \ell } } \frac { \partial \lambda _ { k } ( \theta ; w _ { \ell } ) } { \partial \theta } | _ { \theta _ { k } } \| _ { \tilde { w } _ { \ell } } \frac  \partial ( l ( y _  j  \end{array}
+$$
+
+And for the second term,
+
+$$
+\| ( G _ { i j } ) \frac { \partial ^ { 2 } \lambda _ { j } ( \theta ; w _ { t } ) } { \partial \theta ^ { 2 } } | _ { \theta _ { t } } \| = \| \frac { \partial L _ { i } ^ { c } ( \hat { w } ) } { \partial \hat { w } } | _ { \hat { w } _ { t } } ^ { T } \frac { \partial ( l ( y _ { j } , \hat { y } _ { j } ) - l ( \tilde { y } _ { j } , \hat { y } _ { j } ) ) } { \partial w _ { t } } | _ { w _ { t } } \frac { \partial ^ { 2 } \lambda _ { j } ( \theta ; w _ { t } ) } { \partial \theta ^ { 2 } } | _ { \theta _ { t } } \| \leq 2 \mathcal { B } \rho ^ { 2 } .
+$$
+
+Therefore,
+
+$$
+\| \nabla _ { \theta ^ { 2 } } ^ { 2 } L _ { i } ^ { c } ( \hat { w } ( \theta ) ) | _ { \theta _ { t } } \| \leq 4 \alpha ^ { 2 } L \rho ^ { 2 } \delta ^ { 2 } + 2 \alpha \rho ^ { 2 } \mathcal { B } .
+$$
+
+Let $L _ { v } = 4 \alpha ^ { 2 } L \rho ^ { 2 } \delta ^ { 2 } + 2 \alpha \rho ^ { 2 } \beta$ ,Based on Lagrange mean value theorem, we have
+
+$$
+\lVert \nabla _ { \theta } L ^ { c } ( \hat { w } _ { t } ( \theta _ { 1 } ) ) - \nabla _ { \theta } L ^ { c } ( \hat { w } _ { t } ( \theta _ { 2 } ) ) \rVert \leq L _ { v } \lVert \theta _ { 1 } - \theta _ { 2 } \rVert ,
+$$
+
+for all $\theta _ { 1 } , \theta _ { 2 }$
+
+Theorem 1. Suppose the loss function $l$ is L-Lipschitz smooth, and $\lambda ( \cdot )$ is differential with a $\delta$ - bounded gradient, twice differential with its Hessian bounded by $\boldsymbol { B }$ with respect to $\theta$ . Let the learning rate $\alpha _ { t } = \operatorname* { m i n } \{ 1 , { \frac { k } { T } } \}$ , for some $k > 0$ , such that $\begin{array} { r } { { \frac { k } { T } } < 1 } \end{array}$ and learning rate $\beta _ { t }$ a monotone descent sequence, $\begin{array} { r } { \beta _ { t } = \operatorname* { m i n } \{ \frac { 1 } { L } , \frac { c } { \sqrt { T } } \} } \end{array}$ for some $c > 0$ , such that $L \leq { \frac { c } { \sqrt { T } } }$ and $\begin{array} { r } { \sum _ { t = 1 } ^ { \infty } \beta _ { t } \le \infty , \sum _ { t = 1 } ^ { \infty } \beta _ { t } ^ { 2 } \le } \end{array}$ $\infty$ . Then the loss of Aggregation Net can achieve $\| \nabla _ { \theta } L ^ { c } ( \hat { w } ( \theta _ { t } ) ) \| _ { 2 } ^ { 2 } \le \epsilon$ in $\mathcal { O } ( 1 / \epsilon ^ { 2 } )$ steps. More specifically,
+
+$$
+\operatorname* { m i n } _ { 0 \leq t \leq T } \| \nabla _ { \boldsymbol { \theta } } L ^ { c } ( \hat { w } ( \boldsymbol { \theta } _ { t } ) ) \| _ { 2 } ^ { 2 } \leq \mathcal { O } ( \frac { C } { \sqrt { T } } ) .
+$$
+
+Proof. The iteration for updating the parameter $\theta$ reads
+
+$$
+\theta _ { t + 1 } = \theta _ { t } - \beta \nabla _ { \theta } L ^ { c } ( \hat { w } _ { t } ( \theta ) ) | _ { \theta _ { t } } .
+$$
+
+In two successive iteration, observe that
+
+$$
+\begin{array} { r l } & { \quad L ^ { c } ( \hat { w } _ { t + 1 } ( \theta _ { t + 1 } ) ) - L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) } \\ & { = [ L ^ { c } ( \hat { w } _ { t + 1 } ( \theta _ { t + 1 } ) ) - L ^ { c } ( \hat { w } _ { t } ( \theta _ { t + 1 } ) ) ] + [ L ^ { c } ( \hat { w } _ { t } ( \theta _ { t + 1 } ) ) - L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) ] . } \end{array}
+$$
+
+For the first term, given that loss function on clean set is Lipschitz smooth, we have
+
+$$
+\begin{array} { r l } & { \quad L ^ { c } ( \hat { w } _ { t + 1 } ( \theta _ { t + 1 } ) ) - L ^ { c } ( \hat { w } _ { t } ( \theta _ { t + 1 } ) ) } \\ & { \leq < \nabla L ^ { c } ( \hat { w } _ { t } ( \theta _ { t + 1 } ) ) , \hat { w } _ { t + 1 } ( \theta _ { t + 1 } ) - \hat { w } _ { t } ( \theta _ { t + 1 } ) > + \displaystyle \frac { L } { 2 } \| \hat { w } _ { t + 1 } ( \theta _ { t + 1 } ) - \hat { w } _ { t } ( \theta _ { t + 1 } ) \| _ { 2 } ^ { 2 } . } \end{array}
+$$
+
+According to Equation (20) and (23),
+
+$$
+\hat { w } _ { t + 1 } ( \theta _ { t + 1 } ) - \hat { w } _ { t } ( \theta _ { t + 1 } ) = - \frac { \alpha _ { t } } { n } \sum _ { j = 1 } ^ { n } [ \lambda _ { j } \nabla _ { w } l ( y _ { j } , \hat { y } _ { j } ) + ( 1 - \lambda _ { j } ) \nabla _ { w } l ( \tilde { y } _ { j } , \hat { y } _ { j } ) ] | _ { w _ { t + 1 } } ,
+$$
+
+and thus,
+
+$$
+\| L ^ { c } ( \hat { w } _ { t + 1 } ( \theta _ { t + 1 } ) ) - L ^ { c } ( \hat { w } _ { t } ( \theta _ { t + 1 } ) ) \| \leq \alpha _ { t } \rho ^ { 2 } + \frac { L } { 2 } \alpha _ { t } ^ { 2 } \rho ^ { 2 } ,
+$$
+
+since the first gradient of loss function is bounded by $\rho$
+
+By the Lipschitz continuity of $L ^ { c } ( \hat { w } _ { t } ( \theta ) )$ according to Lemma 1., it can be obtained that
+
+$$
+\begin{array} { r l } & { \quad L ^ { c } ( \hat { w } _ { t } ( \theta _ { t + 1 } ) ) - L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) } \\ & { \le \langle \nabla _ { \theta _ { t } } L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) , \theta _ { t + 1 } - \theta _ { t } \rangle + \displaystyle \frac { L } { 2 } \| \theta _ { t + 1 } - \theta _ { t } \| _ { 2 } ^ { 2 } } \\ & { = \langle \nabla _ { \theta _ { t } } L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) , - \beta _ { t } \nabla _ { \theta _ { t } } L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) \rangle + \displaystyle \frac { L \beta _ { t } ^ { 2 } } { 2 } \| \nabla _ { \theta _ { t } } L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) \| _ { 2 } ^ { 2 } } \\ & { = - ( \beta _ { t } - \displaystyle \frac { L \beta _ { t } ^ { 2 } } { 2 } ) \| \nabla _ { \theta _ { t } } L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) \| _ { 2 } ^ { 2 } . } \end{array}
+$$
+
+Therefore, the Equation (32) satisfies
+
+$$
+\begin{array} { r l r } & { } & { L ^ { c } ( \hat { w } _ { t + 1 } ( \theta _ { t + 1 } ) ) - L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) \le \alpha _ { t } \rho ^ { 2 } + \displaystyle \frac { L } { 2 } \alpha _ { t } ^ { 2 } \rho ^ { 2 } - ( \beta _ { t } - \frac { L \beta _ { t } ^ { 2 } } { 2 } ) \| \nabla _ { \theta _ { t } } L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) \| _ { 2 } ^ { 2 } } \\ & { } & { ( \beta _ { t } - \frac { L \beta _ { t } ^ { 2 } } { 2 } ) \| _ { 2 } ^ { 2 } \nabla _ { \theta _ { t } } L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) \| _ { 2 } ^ { 2 } \le \alpha _ { t } \rho ^ { 2 } + \displaystyle \frac { L } { 2 } \alpha _ { t } ^ { 2 } \rho ^ { 2 } - L ^ { c } ( \hat { w } _ { t + 1 } ( \theta _ { t + 1 } ) ) + L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) . } \end{array}
+$$
+
+Summing up above inequalities from 1 to $T$ , we have
+
+$$
+\begin{array} { r } { \displaystyle \sum _ { t = 1 } ^ { T } ( \beta _ { t } - \frac { L \beta _ { t } ^ { 2 } } { 2 } ) \| \nabla _ { \theta _ { t } } L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) \| _ { 2 } ^ { 2 } \leq L ^ { c } ( \hat { w } _ { 1 } ( \theta _ { 1 } ) ) + \displaystyle \sum _ { t = 1 } ^ { T } ( \alpha _ { t } \rho ^ { 2 } + \frac { L } { 2 } \alpha _ { t } ^ { 2 } \rho ^ { 2 } ) } \\ { \displaystyle \sum _ { t = 1 } ^ { T } ( \beta _ { t } - \frac { L \beta _ { t } ^ { 2 } } { 2 } ) \operatorname* { m i n } _ { t } \| \nabla _ { \theta _ { t } } L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) \| _ { 2 } ^ { 2 } \leq L ^ { c } ( \hat { w } _ { 1 } ( \theta _ { 1 } ) ) + \displaystyle \sum _ { t = 1 } ^ { T } ( \alpha _ { t } \rho ^ { 2 } + \frac { L } { 2 } \alpha _ { t } ^ { 2 } \rho ^ { 2 } ) . } \end{array}
+$$
+
+Furthermore,
+
+$$
+\begin{array} { r l } { \operatorname* { m i n } _ { 1 } \| \nabla _ { 0 } , L ^ { \nu } ( \hat { \omega } ; \hat { \omega } _ { \hat { \omega } } ^ { \dagger } ) \| _ { 2 } ^ { 2 } \leq \frac { L ^ { 2 } ( \hat { \omega } ; \hat { \omega } ( \hat { \omega } _ { \hat { \omega } } ( \hat { \theta } _ { 1 } ) ) + 1 ) - \sum _ { i = 1 } ^ { N } ( \alpha _ { i } \mu ^ { 2 } + \frac { L ^ { 2 } } { 2 } \hat { \omega } _ { \hat { \omega } } ^ { 2 } \hat { \omega } _ { \hat { \omega } } ^ { 2 } ) } { \sum _ { \alpha ^ { \prime } = 1 } ^ { N } ( \beta _ { i } - \frac { L ^ { 2 } } { 2 } \mu ^ { 2 } ) } } \\ & { \leq \frac { 2 L ^ { 2 } ( \hat { \omega } ; \hat { \omega } ( \hat { \omega } _ { 1 } ( \hat { \omega } _ { 1 } ) ) + \sum _ { i = 1 } ^ { N } ( 2 \omega _ { i } \mu ^ { 2 } + \frac { L ^ { 2 } } { 2 } \mu ^ { 2 } ) + L ^ { 2 } \mu ^ { 2 } ) } { \sum _ { \alpha ^ { \prime } = 1 } ^ { N } ( 2 \hat { \omega } _ { \hat { \omega } } - \frac { L ^ { 2 } } { 2 } ) } } \\ & { \leq \frac { 2 L ^ { 2 } ( \hat { \omega } ; \hat { \omega } ( \hat { \omega } _ { 1 } ( \hat { \omega } _ { 1 } ) ) + \sum _ { i = 1 } ^ { N } ( 2 \omega _ { i } \mu ^ { 2 } + L ^ { 2 } \omega ^ { 2 } ) + L ^ { 2 } \mu ^ { 2 } ) } { \sum _ { \alpha ^ { \prime } = 1 } ^ { N } ( \beta _ { i } ) } } \\ & { \leq \frac { 2 L ^ { 2 } ( \hat { \omega } ; \hat { \omega } ( \hat { \omega } _ { 1 } ( \hat { \omega } _ { 1 } ) ) + \sum _ { i = 1 } ^ { N } ( 2 \omega _ { i } \mu ^ { 2 } + L ^ { 2 } \omega ^ { 2 } ) } { \sum _ { \alpha ^ { \prime } = 1 } ^ { N } ( \beta _ { i } ) } } \\ &  \leq \frac  2 L ^ { 2 } ( \hat { \omega } ; \hat { \omega } ( \hat { \omega } _ { 1 } ) ) - 2 ( \hat { \omega } ; \hat { \omega } ^ { 2 } ) + L ^ { 2 } ( 2  \end{array}
+$$
+
+It holds for $\begin{array} { r } { \sum _ { t = 1 } ^ { T } ( \beta _ { t } ) \leq \sum _ { t = 1 } ^ { T } ( 2 \beta _ { t } - L \beta _ { t } ^ { 2 } ) } \end{array}$ . In conclusion, it proves that the algorithm can always achieve $\begin{array} { r } { \operatorname* { m i n } _ { 0 \leq t \leq T } \| \nabla _ { \theta } L ^ { c } ( \hat { w } ( \theta _ { t } ) ) \| _ { 2 } ^ { 2 } \leq \mathcal { O } ( \frac { 1 } { \sqrt { T } } ) } \end{array}$ in $T$ steps.
+
+Lemma 2. Let $( a _ { n } ) _ { 1 \leq n } , ( b _ { n } ) _ { 1 \leq n }$ be two non-negative re nces such that the series $\textstyle \sum _ { i _ { i } } ^ { \infty } a _ { n }$ diverges, the series $\textstyle \sum _ { i _ { i } } ^ { \infty } a _ { n } b _ { n }$ converges, and there exists $K > 0$ such that $\| b _ { n + 1 } - b _ { n } \| \leq \dot { K } a _ { n }$ . Then the seqences $\left( b _ { n } \right) _ { 1 \leq n }$ converges to 0.
+
+Proof. See the proof of Lemma A.5 in [Stochastic majorization-minimization algorithms for ].
+
+Theorem 2. Suppose the loss function $l$ is L-Lipschitz smooth and have $\rho$ -bounded gradients with respect to training data and clean set, and $\lambda ( \cdot )$ is differential with a $\delta$ -bounded gradient twice differential with its Hessian bounded by $\boldsymbol { B }$ with respect to $\theta$ . Let the learning rate $\alpha _ { t } = \operatorname* { m i n } \{ 1 , { \frac { k } { T } } \}$ , for some $k > 0$ , such that $\begin{array} { r } { { \frac { k } { T } } < 1 } \end{array}$ and learning rate $\beta _ { t }$ a monotone descent sequence, $\begin{array} { r } { \beta _ { t } = \operatorname* { m i n } \{ \frac { 1 } { L } , \frac { c } { \sqrt { T } } \} } \end{array}$ for some $c > 0$ , such that $L \leq { \frac { c } { \sqrt { T } } }$ and $\begin{array} { r } { \sum _ { t = 1 } ^ { \infty } \beta _ { t } \leq \infty , \sum _ { t = 1 } ^ { \infty } \beta _ { t } ^ { 2 } \leq \infty } \end{array}$ . Then
+
+$$
+\operatorname* { l i m } _ { t \to \infty } \| \nabla _ { w _ { t } } L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) \| _ { 2 } ^ { 2 } = 0 .
+$$
+
+Proof. It is obvious that $a _ { t }$ satisfy $\begin{array} { r } { \sum _ { t = 0 } ^ { \infty } a _ { t } = \infty , \sum _ { t = 0 } ^ { \infty } a _ { t } \le \infty . } \end{array}$ . In Eq. 18, 19, 20, and the linearity of $L$ , we rewrite the update of $w$ as
+
+$$
+\begin{array} { l } { { \displaystyle w _ { t + 1 } = w _ { t } - \alpha _ { t } \nabla L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) } } \\ { { \displaystyle \qquad = w _ { t } - \frac { \alpha _ { t } } { n } \sum _ { j = 1 } ^ { n } \lambda _ { j } ( \theta _ { t + 1 } ; w _ { t } ) \nabla _ { w _ { t } } l ( y _ { j } , \hat { y } _ { j } ( w _ { t } ) ) + ( 1 - \lambda _ { j } ( \theta _ { t + 1 } ; w _ { t } ) ) \nabla _ { w _ { t } } l ( \tilde { y } _ { j } , \hat { y } _ { j } ( w _ { t } ) ) . } } \end{array}
+$$
+
+First, we have the difference of the loss function on training set between two iterations,
+
+$$
+\begin{array} { r l } & { \quad L ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 2 } ) - L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) } \\ & { = \lbrack L ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 2 } ) - L ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 1 } ) \rbrack + \lbrack L ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 1 } ) - L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) \rbrack . } \end{array}
+$$
+
+For the first term in Eq.33, by the L-Lipschitz-smooth and $\rho$ −bounded gradients of $\lambda$ with respect to training and clean set,
+
+$$
+\begin{array} { l } { { \displaystyle { \cal L } ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 2 } ) - { \cal L } ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 1 } ) } } \\  { \displaystyle { = \frac { 1 } { n } \sum _ { j = 1 } ^ { n } ( \lambda _ { j } ( \theta _ { t + 2 } ; w _ { t + 1 } ) - \lambda _ { j } ( \theta _ { t + 1 } ; w _ { t + 1 } ) ) l ( y _ { j } , \hat { y } ( w _ { t + 1 } ) ) + ( \lambda _ { j } ( \theta _ { t + 1 } ; w _ { t + 1 } ) - \lambda _ { j } ( \theta _ { t + 2 } ; w _ { t + 1 } ) ) l ( \tilde { y } _ { j } , \hat { y } ( w _ { t + 1 } ) ) } } \\  { \displaystyle { \le \frac { 1 } { n } \sum _ { j = 1 } ^ { n } ( \left. \frac { \partial \lambda _ { j } ( \theta _ { j } ; w _ { t + 1 } ) } { \partial \theta } \vert _ { \theta _ { t + 1 } } , \theta _ { t + 2 } - \theta _ { t + 1 } \right. + \frac { \delta } { 2 } \| \theta _ { t + 2 } - \theta _ { t + 1 } \| _ { 2 } ^ { 2 } ) ( l ( y _ { j } , \hat { y } ( w _ { t + 1 } ) ) + l ( y _ { j } , \hat { y } ( w _ { t + 1 } ) ) ) } } \\  { \displaystyle { = \frac { 1 } { n } \sum _ { j = 1 } ^ { n } ( \left. \frac { \partial \lambda _ { j } ( \theta ; w _ { t + 1 } ) } { \partial \theta } \vert _ { \theta ^ { t + 1 } } , - \beta _ { t } \nabla _ { \theta _ { t } } L ( \hat { w } _ { t } ( \theta _ { t } ) ) \right. + \frac { \delta \beta _ { t } ^ { 2 } } { 2 } \| \nabla _ { \theta _ { t } } L ( \hat { w } _ { t } ( \theta _ { t } ) ) \| _ { 2 } ^ { 2 } ) ( l ( y _ { j } , \hat { y } ( w _ { t + 1 } ) ) + l ( y _ { j } , \hat { y } ( w _ { t + 1 } ) ) ) } } \end{array}
+$$
+
+For the second term in Eq. 33,
+
+$$
+\begin{array} { r l } & { \quad L ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 1 } ) - L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) } \\ & { \le \bigl \langle \nabla _ { w _ { t } } L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) , w _ { t + 1 } - w _ { t } \bigr \rangle + \frac { L } { 2 } \| w _ { t + 1 } - w _ { t } \| _ { 2 } ^ { 2 } } \\ & { = - \bigl ( \alpha _ { t } - \frac { L a _ { t } ^ { 2 } } { 2 } \bigr ) \| \nabla _ { w _ { t } } L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) \| _ { 2 } ^ { 2 } . } \end{array}
+$$
+
+Therefore, we have
+
+$$
+\begin{array} { r l } & { \quad L ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 2 } ) - L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) } \\ & { \le \displaystyle \frac { 1 } { n } \sum _ { j = 1 } ^ { n } ( \left. \frac { \partial \lambda _ { j } ( \theta ; w _ { t + 1 } ) } { \partial \theta } | _ { \theta ^ { t + 1 } } , - \beta _ { t } \nabla _ { \theta _ { t } } L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) \right. } \\ & { + \displaystyle \frac { \delta \beta _ { t } ^ { 2 } } { 2 } \| \nabla _ { \theta _ { t } } L ( \hat { w } _ { t } ( \theta _ { t } ) ) \| _ { 2 } ^ { 2 } ) ( l ( y _ { j } , \hat { y } ( w _ { t + 1 } ) ) + l ( y _ { j } , \hat { y } ( w _ { t + 1 } ) ) ) } \\ & { - ( \alpha _ { t } - \frac { L \alpha _ { t } ^ { 2 } } { 2 } ) \| \nabla _ { w _ { t } } L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) \| _ { 2 } ^ { 2 } . } \end{array}
+$$
+
+Summing up the inequalities in both sides from $t = 1$ to $\infty$ , we have
+
+$$
+\begin{array} { r l } & { \displaystyle \underset { t = 1 } { \operatorname* { l i m } } \| L ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 2 } ) - L ^ { t r } ( w _ { 1 } ; \theta _ { 2 } ) \| } \\ & { \le \displaystyle \sum _ { t = 1 } ^ { \infty } - \frac { \beta _ { t } } { n } \sum _ { j = 1 } ^ { n } [ \| \frac { \partial \lambda _ { j } ( \theta ; w _ { t + 1 } ) } { \partial \theta } | _ { \theta ^ { t + 1 } } \| _ { 2 } \| \nabla _ { \theta _ { t } } L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) \| _ { 2 } ( \| l ( y _ { j } , \hat { y } ( w _ { t + 1 } ) ) \| _ { 2 } + \| l ( y _ { j } , \hat { y } ( w _ { t + 1 } ) ) \| _ { 2 } , } \\ & { + \displaystyle \sum _ { t = 1 } ^ { \infty } \frac { \delta \beta _ { t } ^ { 2 } } { 2 } \displaystyle \sum _ { j = 1 } ^ { n } \| \nabla _ { \theta _ { t } } L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) \| _ { 2 } ^ { 2 } ] ( \| l ( y _ { j } , \hat { y } ( w _ { t + 1 } ) ) \| _ { 2 } + \| l ( y _ { j } , \hat { y } ( w _ { t + 1 } ) ) \| _ { 2 } ) } \\ & { - \displaystyle \sum _ { t = 1 } ^ { \infty } ( \alpha _ { t } - \frac { L \alpha _ { t } ^ { 2 } } { 2 } ) \| \nabla _ { w _ { t } } L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) \| _ { 2 } ^ { 2 } . } \end{array}
+$$
+
+Rearrange the terms of the inequality, we obtain
+
+$$
+\begin{array} { r l } & { \displaystyle \sum _ { t = 1 } ^ { \infty } \alpha _ { t } \| \nabla _ { w _ { 1 } } L ^ { t \top } ( w _ { : t } , \theta _ { t + 1 } ) \| _ { 2 } ^ { 2 } } \\ & { + \displaystyle \sum _ { t = 1 } ^ { \infty } \frac { \beta _ { t } } { \eta } \displaystyle \sum _ { j = 1 } ^ { n } \| \frac { \partial \lambda _ { t } ( \theta ; w _ { t + 1 } ) } { \partial \theta } | _ { \theta ^ { ( 1 ) } } \| _ { \theta ^ { ( 1 ) } } \| _ { 2 } \| \nabla _ { \theta , L ^ { t } } ( \bar { w } _ { t } , \theta _ { t } ) \| _ { 2 } \| \boldsymbol { l } ( \vartheta _ { j } , \hat { \theta } ( w _ { + 1 } ) ) \| _ { 2 } + \| \boldsymbol { l } ( \boldsymbol { y } _ { j } , \hat { \psi } ( w _ { * + 1 } ) ) \| _ { 2 } ) } \\ & { \leq \displaystyle \sum _ { t = 1 } ^ { L \alpha _ { t } } \| \nabla _ { w _ { 1 } } L ^ { t \top } ( w _ { t } ; \theta _ { t + 1 } ) \| _ { 2 } ^ { 2 } } \\ & { + \displaystyle \sum _ { t = 1 } ^ { \infty } \frac { \delta \beta _ { t } ^ { 2 } } { 2 } \displaystyle \sum _ { s = 1 } ^ { n } \| \nabla _ { v _ { 1 } } L ^ { t \top } ( w _ { 1 } ; \theta _ { t } ) ) \| _ { 2 } ^ { 2 } \| \boldsymbol { l } ( \boldsymbol { l } ; \theta _ { s } , \hat { \boldsymbol { y } } ( w _ { t + 1 } ) ) \| _ { 2 } + \| \boldsymbol { l } ( \boldsymbol { y } _ { s } , \hat { \boldsymbol { y } } ( w _ { t + 1 } ) ) \| _ { 2 } ) } \\ & { - \displaystyle \operatorname* { l i m } _ { t = 1 } ^ { \infty } [ L ^ { t \top } ( w _ { t + 1 } ; \theta _ { t + 2 } ) ] + \| L ^ { t t \top } ( w _ { 1 } ; \theta _ { 2 } ) \| _ { 2 } } \\ &  \leq \displaystyle \sum _ { t = 1 } ^ { \infty } \frac { L \alpha _ { t } } { 2 } \rho ^ { 2 } + \| L ^ { t t } ( w _ { 1 } ; \theta _ { 2 } ) \| _ { 2 } + \displaystyle \sum _ { t = 1 } ^ { \infty } \frac { \delta \beta _ { t } ^ { 2 } } { 2 } ( 2 \boldsymbol { y } _ { t } ) ^  2  \end{array}
+$$
+
+The inequality next to last holds since our loss function is bounded by $M$ , and the last one holds for $\textstyle \sum _ { t = 1 } ^ { \infty } \alpha _ { t } ^ { 2 }$ and $\textstyle \sum _ { t = 1 } ^ { \infty } \beta _ { t } ^ { 2 }$ are finite.
+
+In addition, since
+
+$$
+\begin{array} { r l } & { \displaystyle \sum _ { t = 1 } ^ { \infty } \frac { \beta _ { t } } { n } \sum _ { j = 1 } ^ { n } \| \frac { \partial \lambda _ { j } ( \theta ; w _ { t + 1 } ) } { \partial \theta } | _ { \theta ^ { t + 1 } } \| _ { 2 } \| \nabla _ { \theta _ { t } } L ^ { c } ( \hat { w } _ { t } ( \theta _ { t } ) ) \| _ { 2 } \big ( \| l ( y _ { j } , \hat { y } ( w _ { t + 1 } ) \big ) \| _ { 2 } + \| l ( y _ { j } , \hat { y } ( w _ { t + 1 } ) \big ) \| _ { 2 } \big ) } \\ & { \displaystyle \le 2 M \rho \delta \sum _ { t = 1 } ^ { \infty } \beta _ { t } \le \infty , } \end{array}
+$$
+
+we can obtain that
+
+$$
+\sum _ { t = 1 } ^ { \infty } \alpha _ { t } \| \nabla _ { w _ { t } } L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) \| _ { 2 } ^ { 2 } \leq \infty .
+$$
+
+In the other hand, based on the inequality:
+
+$$
+( \| a \| + \| b \| ) ( \| a \| - \| b \| ) \leq \| a + b \| \| a - b \| ,
+$$
+
+we have
+
+$$
+\begin{array} { r l } & { \quad \| \nabla L ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 2 } ) \| _ { 2 } ^ { 2 } - \| \nabla L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) \| _ { 2 } ^ { 2 } \| } \\ & { = ( \| \nabla L ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 2 } ) \| _ { 2 } + \| \nabla L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) \| _ { 2 } ) ( \| \nabla L ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 2 } ) \| _ { 2 } - \| \nabla L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) \| _ { 2 } ) } \\ & { \le \| \nabla L ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 2 } ) + \nabla L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) \| _ { 2 } \| \| _ { 2 } \| \nabla L ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 2 } ) - \nabla L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) \| _ { 2 } } \\ & { \le ( \| \nabla L ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 2 } ) \| _ { 2 } + \| \nabla L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) \| _ { 2 } ) \| \nabla L ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 2 } ) - \nabla L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) \| _ { 2 } ) } \\ & { \le 2 L \rho \| ( w _ { t + 1 } , \theta _ { t + 2 } ) - ( w _ { t } , \theta _ { t + 1 } ) \| _ { 2 } } \\ & { \le 2 L \rho \alpha _ { t } \beta _ { t } \| ( \nabla L ^ { t r } ( w _ { t } , \theta _ { t + 1 } ) , \nabla L ^ { c } ( w _ { t } , \theta _ { t + 1 } ) ) \| _ { 2 } } \\ & { \le 2 \sqrt { 2 } L \rho ^ { 2 } \beta _ { 1 } \alpha _ { t } } \end{array}
+$$
+
+For Eq. 34 which reads
+
+$$
+\sum _ { t = 1 } ^ { \infty } \alpha _ { t } \| \nabla _ { w _ { t } } L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) \| _ { 2 } ^ { 2 } \leq \infty ,
+$$
+
+since $\textstyle \sum _ { t = 0 } ^ { \infty } \alpha _ { t } \ = \ \infty$ , and there exists $K \ = \ C \ > \ 0$ , such that $\big | \big | \nabla L ^ { t r } ( w _ { t + 1 } ; \theta _ { t + 2 } ) \big | \big | _ { 2 } ^ { 2 } \ -$ $\| \nabla L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) \| _ { 2 } ^ { 2 } | \le C \alpha _ { t }$ , by Lemma 2., we can conclude that
+
+$$
+\operatorname* { l i m } _ { t \to \infty } \| \nabla _ { w _ { t } } L ^ { t r } ( w _ { t } ; \theta _ { t + 1 } ) \| _ { 2 } ^ { 2 } = 0 ,
+$$
+
+which indicates that the gradient of loss on training set of our algorithm will finally achieve to zero, and thus the iteration of $w$ enables training loss to converge.

parse/train/MD3D5UbTcb1/MD3D5UbTcb1.md

@@ -0,0 +1,488 @@
+# A UNIFIED VIEW ON GRAPH NEURAL NETWORKS AS GRAPH SIGNAL DENOISING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Graph Neural Networks (GNNs) have risen to prominence in learning representations for graph structured data. A single GNN layer typically consists of a feature transformation and a feature aggregation operation. The former normally uses feed-forward networks to transform features, while the latter aggregates the transformed features over the graph. Numerous recent works have proposed GNN models with different designs in the aggregation operation. In this work, we establish mathematically that the aggregation processes in a group of representative GNN models including GCN, GAT, PPNP, and APPNP can be regarded as (approximately) solving a graph denoising problem with a smoothness assumption. Such a unified view across GNNs not only provides a new perspective to understand a variety of aggregation operations but also enables us to develop a unified graph neural network framework UGNN. To demonstrate its promising potential, we instantiate a novel GNN model, ADA-UGNN, derived from UGNN, to handle graphs with adaptive smoothness across nodes. Comprehensive experiments show the effectiveness of ADA-UGNN.
+
+# 1 INTRODUCTION
+
+Graph Neural Networks (GNNs) have shown great capacity in learning representations for graphstructured data and thus have facilitated many down-stream tasks such as node classification (Kipf & Welling, 2016; Velickovi ˇ c et al. ´ , 2017; Ying et al., 2018a; Klicpera et al., 2018) and graph classification (Defferrard et al., 2016; Ying et al., 2018b). As traditional deep learning models, a GNN model is usually composed of several stacking GNN layers. Given a graph $\mathcal { G }$ with $N$ nodes, a GNN layer typically contains a feature transformation and a feature aggregation operation as:
+
+Feature Transformation: ${ \bf X } _ { i n } ^ { \prime } = f _ { t r a n s } ( { \bf X } _ { i n } )$ ; Feature Aggregation: ${ \bf X } _ { o u t } = f _ { a g g } ( { \bf X } _ { i n } ^ { \prime } ; \mathcal { G } )$ (1) where ${ \bf X } _ { i n } \in \mathbb { R } ^ { N \times d _ { i n } }$ and $\mathbf { X } _ { o u t } \in \mathbb { R } ^ { N \times d _ { o u t } }$ denote the input and output features of the GNN layer with $d _ { i n }$ and $d _ { o u t }$ as the corresponding dimensions, respectively. Note that the non-linear activation is not included in Eq. (1) to ease the discussion. The feature transformation operation $f _ { t r a n s } ( \cdot )$ transforms the input of ${ \bf X } _ { i n }$ to $\mathbf { X } _ { i n } ^ { \prime } \in \mathbb { R } ^ { N \times d _ { o u t } }$ as its output; and the feature aggregation operation $f _ { a g g } ( \cdot ; \mathcal { G } )$ updates the node features by aggregating the transformed node features via the graph $\mathcal { G }$ .
+
+In general, different GNN models share similar feature transformations (often, a single feed-forward layer), while adopting different designs for aggregation operation. We raise a natural question – is there an intrinsic connection among these feature aggregation operations and their assumptions? The significance of a positive answer to this question is two-fold. Firstly, it offers a new perspective to create a uniform understanding on representative aggregation operations. Secondly, it enables us to develop a general GNN framework that not only provides a unified view on multiple existing representative GNN models, but also has the potential to inspire new ones. In this paper, we aim to build the connection among feature aggregation operations of representative GNN models including GCN (Kipf & Welling, 2016), GAT (Velickovi ˇ c et al. ´ , 2017), PPNP and APPNP (Klicpera et al., 2018). In particular, we mathematically establish that the aggregation operations in these models can be unified as the process of exactly, and sometimes approximately, addressing a graph signal denoising problem with Laplacian regularization (Shuman et al., 2013). This connection suggests that these aggregation operations share a unified goal: to ensure feature smoothness of connected nodes. With this understanding, we propose a general GNN framework, UGNN, which not only provides a straightforward, unified view for many existing aggregation operations, but also suggests various promising directions to build new aggregation operations suitable for distinct applications. To demonstrate its potential, we build an instance of UGNN called ADA-UGNN, which is suited for handling varying smoothness properties across nodes, and conduct experiments to show its effectiveness.
+
+# 2 REPRESENTATIVE GRAPH NEURAL NETWORKS
+
+In this section, we introduce notations for graphs and briefly summarize several representative GNN models. A graph can be denoted as $\mathcal { G } = \{ \dot { \mathcal { V } } , \mathcal { E } \}$ , where $\nu$ and $\mathcal { E }$ are its corresponding node and edge sets. The connections in $\mathcal { G }$ can be represented as an adjacency matrix $\mathbf { A } \in \bar { \mathbb { R } } ^ { N \times N }$ , with $N$ the number of nodes in the graph. The Laplacian matrix of the graph $\mathcal { G }$ is denoted as $\mathbf { L }$ . It is defined as $\mathbf { L } = \mathbf { D } - \mathbf { A }$ , where $\mathbf { D }$ is a diagonal degree matrix corresponding to A. There are also normalized versions of the Laplacian matrix such as $\mathbf { L } = \mathbf { I } - \mathbf { D } ^ { - \frac { 1 } { 2 } } \bar { \mathbf { A } } \mathbf { D } ^ { - \frac { 1 } { 2 } }$ or $\mathbf { L } = \mathbf { I } - \mathbf { D } ^ { - 1 } \mathbf { A }$ . In this work, we sometimes adopt different Laplacians to establish connections between different GNNs and the graph denoising problem, clarifying in the text. In this section, we generally use ${ \bf X } _ { i n } \in \mathbb { R } ^ { N \times d _ { i n } }$ and $\mathbf { X } _ { o u t } \in \mathbb { R } ^ { \bar { N } \times d _ { o u t } }$ to denote input and output features of GNN layers. Next, we describe a few representative GNN models.
+
+# 2.1 GRAPH CONVOLUTIONAL NETWORKS (GCN)
+
+Following Eq. (1), a single layer in GCN (Kipf & Welling, 2016) can be written as follows:
+
+Feature Transformation: $\mathbf { X } _ { i n } ^ { \prime } = \mathbf { X } _ { i n } \mathbf { W }$ ; Feature Aggregation: $\mathbf { X } _ { o u t } = \tilde { \mathbf { A } } \mathbf { X } _ { i n } ^ { \prime }$ ,
+
+where $\mathbf { W } \in \mathbb { R } ^ { d _ { i n } \times d _ { o u t } }$ is a feature transformation matrix, and $\tilde { \mathbf { A } }$ is a normalized adjacency matrix which includes a self-loop, defined as follows:
+
+$$
+\tilde { \mathbf { A } } = \hat { \mathbf { D } } ^ { - \frac { 1 } { 2 } } \hat { \mathbf { A } } \hat { \mathbf { D } } ^ { - \frac { 1 } { 2 } } , \quad \mathrm { w i t h } \quad \hat { \mathbf { A } } = \mathbf { A } + \mathbf { I } \quad \mathrm { a n d } \quad \mathbf { D } = \mathrm { d i a g } ( \sum _ { j } \hat { \mathbf { A } } _ { 1 , j } , \ldots , \sum _ { j } \hat { \mathbf { A } } _ { N , j } ) .
+$$
+
+In practice, multiple GCN layers can be stacked, where each layer takes the output of its previous layer as input. Non-linear activation functions are included between consecutive layers.
+
+# 2.2 GRAPH ATTENTION NETWORKS (GAT)
+
+Graph Attention Networks (GAT) adopts the same feature transformation operation as GCN in Eq. (2). The feature aggregation operation (written node-wise) for a node $i$ is as:
+
+$$
+\mathbf { X } _ { o u t } [ i , : ] = \sum _ { j \in \tilde { \mathcal { N } } ( i ) } \alpha _ { i j } \mathbf { X } _ { i n } ^ { \prime } [ j , : ] , \quad \mathrm { w i t h } \quad \alpha _ { i j } = \frac { \exp \left( e _ { i j } \right) } { \sum _ { k \in \tilde { \mathcal { N } } ( i ) } \exp \left( e _ { i k } \right) } .
+$$
+
+where $\tilde { \mathcal { N } } ( i ) = \mathcal { N } ( i ) \cup \{ i \}$ denotes the neighbors (self-inclusive) of node $i$ , and $\mathbf { X } _ { o u t } [ i , : ]$ is the $i$ -th row of the matrix $\mathbf { X } _ { o u t }$ , i.e. the output node features of node $i$ . In this aggregation operation, $\alpha _ { i j }$ is a learnable attention score to differentiate the importance of distinct nodes in the neighborhood. Specifically, $\alpha _ { i j }$ is a normalized form of $e _ { i j }$ , which is modeled as:
+
+$$
+e _ { i j } = \mathrm { L e a k y R e L U } \left( \left[ \mathbf { X } _ { i n } ^ { \prime } [ i , : ] \Vert \mathbf { X } _ { i n } ^ { \prime } [ j , : ] \right] \mathbf { a } \right)
+$$
+
+where $[ \cdot \| \cdot ]$ denotes the concatenation operation and $\mathbf { a } \in \mathbb { R } ^ { 2 d }$ is a learnable vector. Similar to GCN, a GAT model usually consists of multiple stacked GAT layers.
+
+# 2.3 PERSONALIZED PROPAGATION OF NEURAL PREDICTIONS (PPNP)
+
+Personalized Propagation of Neural Predictions (PPNP) (Klicpera et al., 2018) introduces an aggregation operation based on Personalized PageRank (PPR). Specifically, the PPR matrix is defined as $\alpha ( \mathbf { I } - ( 1 - \alpha ) \tilde { \mathbf { A } } ) ^ { - 1 }$ , where $\alpha \in ( 0 , 1 )$ is a hyper-parameter. The $i j$ -th element of the PPR matrix specifies the influence of node $i$ on node $j$ . The feature transformation operation is modeled as Multi-layer Perception (MLP). The PPNP model can be written in the form of Eq. (1) as follows:
+
+Feature Transformation: ${ \bf X } _ { i n } ^ { \prime } = { \bf M L P } ( { \bf X } _ { i n } )$ ;
+
+Unlike GCN and GAT, PPNP only consists of a single feature aggregation layer, but with a potentially deep feature transformation. Since the matrix inverse in Eq. (6) is costly, Klicpera et al. (2018) also introduces a practical, approximated version of PPNP, called APPNP, where the aggregation operation is performed in an iterative way as:
+
+$$
+\mathbf { X } _ { o u t } ^ { ( k ) } = ( 1 - \alpha ) \tilde { \mathbf { A } } \mathbf { X } _ { o u t } ^ { ( k - 1 ) } + \alpha \mathbf { X } _ { i n } ^ { \prime } \quad k = 1 , \ldots K ,
+$$
+
+where X(0)out $\mathbf { X } _ { o u t } ^ { ( 0 ) } = \mathbf { X } _ { i n } ^ { \prime }$ n and X(K)out is the output of the feature aggregation operation. As proved in Klicpera et al. (2018), $\mathbf { X } _ { o u t } ^ { ( K ) }$ converges to the solution obtained by PPNP, i.e., $\mathbf { X } _ { o u t }$ in Eq. (6).
+
+# 3 GNNS AS GRAPH SIGNAL DENOISING
+
+In this section, we aim to establish the connections between the introduced GNN models and a graph signal denoising problem with Laplacian regularization. We first introduce the problem.
+
+Problem 1 (Graph Signal Denoising with Laplacian Regularization). Suppose that we are given a noisy signal $\bar { \mathbf { X } } \in \bar { \mathbb { R } } ^ { N \times d }$ on a graph $\mathcal { G }$ . The goal of the problem is to recover a clean signal $\mathbf { F } \in \bar { \mathbb { R } ^ { N \times \bar { d } } }$ , assumed to be smooth over $\mathcal { G }$ , by solving the following optimization problem:
+
+$$
+\arg \operatorname* { m i n } _ { \mathbf { F } } \mathcal { L } = \| \mathbf { F } - \mathbf { X } \| _ { F } ^ { 2 } + c \cdot t r ( \mathbf { F } ^ { \top } \mathbf { L } \mathbf { F } ) ,
+$$
+
+Note that the first term guides $\mathbf { F }$ to be close to $\mathbf { X }$ , while the second term $t r ( \mathbf { F } ^ { \top } \mathbf { L F } )$ is the Laplacian regularization that guides the smoothness of $\mathbf { F }$ over the graph. $c > 0$ is a balancing constant. Assuming we adopt the unnormalized version of Laplacian matrix with $\mathbf { L } = \mathbf { D } - \mathbf { A }$ (the adjacency matrix $\mathbf { A }$ is assumed to be binary), the second term in Eq. (8) can be written in an edge-centric way or a node-centric way as:
+
+$$
+| \mathrm { g e - c e n t r i c : } \ c \sum _ { ( i , j ) \in \mathcal { E } } \| \mathbf { F } [ i , : ] - \mathbf { F } [ j , : ] \| _ { 2 } ^ { 2 } ; \quad \mathrm { n o d e - c e n t r i c : } \ \frac { 1 } { 2 } c \sum _ { i \in \mathcal { V } } \sum _ { j \in \tilde { N } ( i ) } \ \| \mathbf { F } [ i , : ] - \mathbf { F } [ j , : ] \| _ { 2 } ^ { 2 } .
+$$
+
+Clearly, from the edge-centric view, the regularization term measures the global smoothness of $\mathbf { F }$ , which is small when connected nodes share similar features. On the other hand, we can view the term $\begin{array} { r } { \sum _ { j \in \tilde { \mathcal { N } } ( i ) } \left\| \mathbf { F } \left[ i , : \right] - \mathbf { F } \left[ j , : \right] \right\| _ { 2 } ^ { 2 } } \end{array}$ as a local smoothness measure for node $i$ as it measures the difference between node $i$ and all its neighbors. The regularization term can then be regarded as a summation of local smoothness over all nodes. Note that the adjacency matrix $\mathbf { A }$ is assumed to be binary when deriving Eq. (9). Similar formulations can also be derived to other types of Laplacian matrices. In the following subsections, we demonstrate the connections between aggregation operations in various GNN models and the graph signal denoising problem.
+
+# 3.1 CONNECTION TO PPNP AND APPNP
+
+In this subsection, we establish the connection between the graph signal denoising problem (8) and the aggregation propagations in PPNP and APPNP in Theorem 1 and Theorem 2, respectively.
+
+Theorem 1. When we adopt the normalized Laplacian matrix $\mathbf { L } = \mathbf { I } - \tilde { \mathbf { A } }$ , with $\tilde { \mathbf { A } }$ defined in Eq. (3), the feature aggregation operation in PPNP (Eq. (6)) can be regarded as exactly solving the graph signal denoising problem (8) with $\mathbf { X } _ { i n } ^ { \prime }$ as the input noisy signal and $\begin{array} { r } { c = \frac { 1 } { \alpha } - 1 } \end{array}$ .
+
+Proof. Note that the objective in Eq. (8) is convex. Hence, its closed-form solution $\mathbf { F } ^ { * }$ to exactly solve the graph signal denosing problem can be obtained by setting its derivative to 0 as:
+
+$$
+{ \frac { \partial { \mathcal { L } } } { \partial \mathbf { F } } } = 2 ( \mathbf { F } - \mathbf { X } ) + 2 c \mathbf { L } \mathbf { F } = 0 \Rightarrow \mathbf { F } ^ { * } = ( \mathbf { I } + c \mathbf { L } ) ^ { - 1 } \mathbf { X }
+$$
+
+Given $\mathbf { L } = \mathbf { I } - \tilde { \mathbf { A } } , \mathbf { F } ^ { * }$ can be reformulated as:
+
+$$
+\mathbf { F } ^ { * } = \left( \mathbf { I } + c \mathbf { L } \right) ^ { - 1 } \mathbf { X } = \left( \mathbf { I } + c \left( \mathbf { I } - \tilde { \mathbf { A } } \right) \right) ^ { - 1 } \mathbf { X } = \frac { 1 } { 1 + c } \left( \mathbf { I } - \frac { c } { 1 + c } \tilde { \mathbf { A } } \right) ^ { - 1 } \mathbf { X }
+$$
+
+The feature aggregation operation in Eq. (6) is equivalent to the closed-form solution in Eq. (11) when we set $\alpha = 1 / ( 1 + c ) \bar { }$ and ${ \bf X } = { \bf X } _ { i n } ^ { \prime }$ . This completes the proof.
+
+Theorem 2. When we adopt the normalized Laplacian matrix $\mathbf { L } = \mathbf { I } - \tilde { \mathbf { A } }$ , the feature aggregation operation in APPNP (Eq. (7)) approximately solves the graph signal denoising problem (8) by iterative gradient descent with $\mathbf { X } _ { i n } ^ { \prime }$ as the input noisy signal, $\begin{array} { r } { c = \frac { 1 } { \alpha } - 1 } \end{array}$ and stepsize $\begin{array} { r } { b = \frac { 1 } { 2 + 2 c } } \end{array}$ .
+
+Proof. To solve the graph signal denoising problem (8), we take iterative gradient method with the stepsize $b$ . Specifically, the $\bar { k }$ -th step gradient descent on problem (8) is as follows:
+
+$$
+\mathbf { F } ^ { ( k ) } \gets \mathbf { F } ^ { ( k - 1 ) } - b \cdot \frac { \partial \mathcal { L } } { \partial \mathbf { F } } ( \mathbf { F } = \mathbf { F } ^ { ( k - 1 ) } ) = ( 1 - 2 b - 2 b c ) \mathbf { F } ^ { ( k - 1 ) } + 2 b \mathbf { X } + 2 b c \tilde { \mathbf { A } } \mathbf { F } ^ { ( k - 1 ) }
+$$
+
+where $\mathbf { F } ^ { ( 0 ) } = \mathbf { X }$ . When we set the stepsize $b$ as $\frac { 1 } { 2 + 2 c }$ , we have the following iterative steps:
+
+$$
+\mathbf { F } ^ { ( k ) }  \frac { 1 } { 1 + c } \mathbf { X } + \frac { c } { 1 + c } \tilde { \mathbf { A } } \mathbf { F } ^ { ( k - 1 ) } , k = 1 , \dots K ,
+$$
+
+which is equivalent to the iterative aggregation operation of the APPNP model in Eq. (7) with $\mathbf { X } = \mathbf { X } _ { i n } ^ { \prime }$ and $\begin{array} { r } { \alpha = \frac { 1 } { 1 + c } } \end{array}$ . This completes the proof. □
+
+These two connections provide a new explanation on the hyper-parameter $\alpha$ in PPNP and APPNP from the graph signal denoising perspective. Specifically, a smaller $\alpha$ indicates a larger $c$ , which means the obtained $\mathbf { X } _ { o u t }$ is enforced to be smoother over the graph.
+
+# 3.2 CONNECTION TO GCN
+
+We draw the connection between the GCN model (Kipf & Welling, 2016) and the graph signal denoising problem in Theorem 3.
+
+Theorem 3. When we adopt the normalized Laplacian matrix $\begin{array} { r } { \mathbf { L } = \mathbf { I } - \tilde { \mathbf { A } } , } \end{array}$ , the feature aggregation operation in GCN Eq. (2) can be regarded as solving the graph signal denoising problem (8) using one-step gradient descent with $\mathbf { X } _ { i n } ^ { \prime }$ as the input noisy signal and stepsize $\begin{array} { r } { b = \frac { 1 } { 2 c } } \end{array}$ .
+
+Proof. The gradient with respect to $\mathbf { F }$ at $\mathbf { X }$ is $\begin{array} { r } { \frac { \partial \mathcal { L } } { \partial \mathbf { F } } | _ { \mathbf { F } = \mathbf { X } } = 2 c \mathbf { L } \mathbf { X } } \end{array}$ . Hence, one-step gradient descent for the graph signal denoising problem (8) can be described as:
+
+$$
+\mathbf { F }  \mathbf { X } - b  { \frac { \partial { \mathcal { L } } } { \partial \mathbf { F } } } | _ { \mathbf { F } = \mathbf { X } } = \mathbf { X } - 2 b c \mathbf { L } \mathbf { X } = ( 1 - 2 b c ) \mathbf { X } + 2 b c { \tilde { \mathbf { A } } } \mathbf { X } .
+$$
+
+When stepsize operation of GC $\smash { b = \frac { 1 } { 2 c } }$ and ${ \bf X } = { \bf X } _ { i n } ^ { \prime }$ , we have $\mathbf { F } \gets \tilde { \mathbf { A } } \mathbf { X } _ { i n } ^ { \prime }$ , which is the same as the aggregation
+
+With this connection, it is easy to verify that a GCN model with multiple GCN layers can be regarded as solving the graph signal denoising problem multiple times with different noisy signals. Specifically, each layer of a GCN model corresponds to a graph signal denoising problem, where the input noisy signal is the output from the previous layer after the feature transformation of the current layer. Note that there are earlier works (NT & Maehara, 2019; Zhao & Akoglu, 2019) drawing connection between GCN and the optimization problem in Eq. (8), where the aggregation operation in GCN is shown to be the first-order approximation of the exact solution.
+
+# 3.3 CONNECTION TO GAT
+
+To establish the connection between graph signal denoising and GAT (Velickovi ˇ c et al. ´ , 2017), in this subsection, we adopt an unnormalized version of the Laplacian. It is defined based on the adjacency matrix with self-loop $\hat { \bf A }$ , i.e. $\mathbf { L } = { \hat { \mathbf { D } } } - { \hat { \mathbf { A } } }$ with $\hat { \bf D }$ denoting the diagonal degree matrix of $\hat { \bf A }$ . Then, the denoising problem in Eq. (8) can be rewritten from a node-centric view as:
+
+$$
+\arg \operatorname* { m i n } _ { \mathbf { F } } \mathcal { L } = \sum _ { i \in \mathcal { V } } \| \mathbf { F } [ i , : ] - \mathbf { X } [ i , : ] \| _ { 2 } ^ { 2 } + \frac { 1 } { 2 } \sum _ { i \in \mathcal { V } } c \cdot \sum _ { j \in \tilde { N } ( i ) } \| \mathbf { F } [ i , : ] - \mathbf { F } [ j , : ] \| _ { 2 } ^ { 2 } ,
+$$
+
+where $\tilde { \mathcal { N } } ( i ) = \mathcal { N } ( i ) \cup \{ i \}$ denotes the neighbors (self-inclusive) of node $i$ . In Eq. (15), the constant $c$ is shared by all nodes, which indicates that the same level of local smoothness is enforced to all nodes. However, nodes in a real-world graph can have varied local smoothness. For nodes with low local smoothness, we should impose a relatively smaller $c$ , while for those nodes with higher local smoothness, we need a larger $c$ . Hence, instead of a unified $c$ as in Eq. (15), we could consider a node-dependent $c _ { i }$ for each node $i$ . Then, the optimization problem in Eq. (15) can be adjusted as:
+
+$$
+\arg \operatorname* { m i n } _ { \mathbf { F } } \mathcal { L } = \sum _ { i \in \mathcal { V } } \| \mathbf { F } \left[ i , : \right] - \mathbf { X } \left[ i , : \right] \| _ { 2 } ^ { 2 } + \frac { 1 } { 2 } \sum _ { i \in \mathcal { V } } c _ { i } \cdot \sum _ { j \in \tilde { \mathcal { N } } ( i ) } \| \mathbf { F } \left[ i , : \right] - \mathbf { F } \left[ j , : \right] \| _ { 2 } ^ { 2 }
+$$
+
+We next show that the aggregation operation in GAT is closely connected to an approximate solution of problem (16) with the help of the following theorem.
+
+Theorem 4. With adaptive stepsize $b _ { i } = 1 / \sum _ { j \in \tilde { \mathcal { N } } ( i ) } ( c _ { i } + c _ { j } )$ for each node i, the process of taking one step of gradient descent from $\mathbf { X }$ to solve problem (16) can be described as follows:
+
+$$
+\mathbf { F } [ i , : ]  \sum _ { j \in \tilde { \mathcal { N } } ( i ) } b _ { i } ( c _ { i } + c _ { j } ) \mathbf { X } [ j , : ] .
+$$
+
+Proof. The gradient of optimization problem in Eq. (16) with respect to $\mathbf { F }$ focusing on a node $i$ can be formulated as:
+
+$$
+\frac { \partial \mathcal { L } } { \partial \mathbf { F } \left[ i , : \right] } = 2 \left( \mathbf { F } \left[ i , : \right] - \mathbf { X } \left[ i , : \right] \right) + \sum _ { j \in \tilde { \mathcal { N } } ( i ) } \left( c _ { i } + c _ { j } \right) \left( \mathbf { F } \left[ i , : \right] - \mathbf { F } \left[ j , : \right] \right) ,
+$$
+
+where $c _ { j }$ in the second term appears since $i$ is also in the neighborhood of $j$ . Then, the gradient at $\mathbf { X }$ is $\frac { \partial \mathcal { L } } { \partial \mathbf { F } [ i , : ] } \Big | _ { \mathbf { F } [ i , : ] = \mathbf { X } [ i , : ] } = \sum _ { j \in \tilde { \mathcal { N } } ( i ) } \left( c _ { i } + c _ { j } \right) \left( \mathbf { X } \left[ i , : \right] - \mathbf { X } \left[ j , : \right] \right)$ . Thus, taking a step of gradient descent starting from $\mathbf { X }$ with stepsize $b$ can be described as follows:
+
+$$
+\mathbf { F } \left[ i , : \right] \gets \mathbf { X } \left[ i , : \right] - b \cdot \left. \frac { \partial \mathcal { L } } { \partial \mathbf { F } \left[ i , : \right] } \right| _ { \mathbf { F } \left[ i , : \right] = \mathbf { X } \left[ i , : \right] } = \left( 1 - b \sum _ { j \in \tilde { N } \left( i \right) } \left( c _ { i } + c _ { j } \right) \right) \mathbf { X } \left[ i , : \right] + \sum _ { j \in \tilde { N } \left( i \right) } b \left( c _ { i } + c _ { j } \right) \mathbf { X } \left[ j , : \right]
+$$
+
+Given $b = 1 / \sum _ { \mathbf { i } } \ \left( c _ { i } + c _ { j } \right)$ , Eq. (19) can be rewritten as $\mathbf { F } [ i , : ]  \sum _ { j \in \tilde { \mathcal { N } } ( i ) } b _ { i } ( c _ { i } + c _ { j } ) \mathbf { X } [ j , : ]$ , which $\mathsf { \Pi } _ { j \in \overline { { \tilde { \mathcal { N } } } } ( i ) }$   
+completes the proof.
+
+Eq. (17) resembles the aggregation operation of GAT in Eq. (4) if we treat $b _ { i } ( c _ { i } + c _ { j } )$ as the attention score $\alpha _ { i j }$ . Note that we have $\sum _ { j \in \tilde { \mathcal { N } } ( i ) } ( c _ { i } + c _ { j } ) = 1 / b _ { i }$ , for all $i \in \mathcal V$ . So, $( c _ { i } + c _ { j } )$ can be regarded as the pre-normalized attention score and $1 / b _ { i }$ can be regarded as the normalization constant. We further compare $b _ { i } ( c _ { i } + c _ { j } )$ with $\alpha _ { i j }$ by investigating the formulation of $e _ { i j }$ in Eq. (5). Eq. (5) can be rewritten as:
+
+$$
+e _ { i j } = \mathrm { L e a k y R e L U } \left( \mathbf { X } _ { i n } ^ { \prime } [ i , : ] \mathbf { a } _ { 1 } + \mathbf { X } _ { i n } ^ { \prime } [ j , : ] \mathbf { a } _ { 2 } \right)
+$$
+
+where $\mathbf { a } _ { 1 } \in \mathbb { R } ^ { d }$ and $\mathbf { a } _ { 2 } \in \mathbb { R } ^ { d }$ are learnable column vectors, which can be concatenated to form a in Eq. (5). Comparing $e _ { i j }$ with $( c _ { i } + c _ { j } )$ , we find that they take a similar form. Specifically, ${ \bf X } _ { i n } ^ { \prime } [ i , : ] { \bf a } _ { 1 }$ and $\mathbf { X } _ { i n } ^ { \prime } [ j , : ] \dot { \mathbf { a } } _ { 2 }$ can be regarded as the approximations of $c _ { i }$ and $c _ { j }$ , respectively. The difference between $b _ { i } ( c _ { i } + c _ { j } )$ and $\alpha _ { i j }$ is that the normalization in Eq. (17) for $b _ { i } \mathbf { \bar { ( } } c _ { i } + c _ { j } \mathbf { ) }$ is achieved via summation rather than a softmax as in Eq. (4) for $\alpha _ { i j }$ . Note that since GAT makes the $c _ { i }$ and $c _ { j }$ learnable, they also include a non-linear activation in calculating $e _ { i j }$ . By viewing the attention mechanism in GAT from the perspective of Eq. (17), namely that $c _ { i }$ actually indicates a notion of local smoothness for node $i$ , we can develop other ways to parameterize $c _ { i }$ . For example, instead of directly using the node features of $i$ as an indicator of local smoothness like GAT, we can consider the neighborhood information. In fact, we adopt this idea to design a new aggregation operation in Section 5.
+
+# 4 UGNN: A UNIFIED GNN FRAMEWORK VIA GRAPH SIGNAL DENOISING
+
+In the previous section, we established that the aggregation operations in PPNP, APPNP, GCN and GAT are intimately connected to the graph signal denoising problem with (generalized) Laplacian regularization. In particular, from this perspective, all their aggregation operations aim to ensure feature smoothness: either a global smoothness over the graph as in PPNP, APPNP and GCN, or a local smoothness for each node as in GAT. This understanding allows us to develop a unified feature aggregation operation by posing the following, more general graph signal denoising problem:
+
+Problem 2 (Generalized UGNN Graph Signal Denoising Problem).
+
+$$
+\arg \operatorname* { m i n } _ { \mathbf { F } } \mathcal { L } = \| \mathbf { F } - \mathbf { X } \| _ { F } ^ { 2 } + r ( \mathcal { C } , \mathbf { F } , \mathcal { G } ) ,
+$$
+
+where $r ( \mathcal { C } , \mathbf { F } , \mathcal { G } )$ denotes a flexible regularization term to enforce some prior over $\mathbf { F }$
+
+Note that we overload the notation $\mathcal { C }$ here: it can function as a scalar (like a global constant in GCN), a vector (like node-wise constants in GAT) or even a matrix (edge-wise constants) if we want to give flexibility to each node pair. Different choices of $r ( \cdot )$ imply different feature aggregation operations. Besides PPNP, APPNP, GCN and GAT, there are aggregation operations in more GNN models that can be associated with Problem 2 with different regularization terms such as PairNorm (Zhao & Akoglu, 2019) and DropEdge (Rong et al., 2019) (more details can be found in Appendix B). The above mentioned regularization terms are all related to the Laplacian regularization. Other regularization terms can also be adopted, which may lead to novel designs of GNN layers. For example, if we aim to enforce that the clean signal is piece-wise linear, we can adopt $r ( \dot { \mathcal { C } } , \mathbf { F } , \mathcal { G } ) = \mathcal { C } \cdot \| \dot { \mathbf { L } } \mathbf { F } \| _ { 1 }$ designed for trend filtering (Tibshirani et al., 2014; Wang et al., 2016).
+
+With these discussions, we propose a unified framework (UGNN) to design GNN layers from the graph signal processing perspective as: (1) Design a graph regularization term $r ( \mathcal { C } , \dot { \bf F } , \mathcal { G } )$ in Problem 2 according to specific applications; (2) Feature Transformation: ${ \bf X } _ { i n } ^ { \prime } = f _ { t r a n s } ( { \bf X } _ { i n } )$ ; and (3) Feature Aggregation: Solving Problem 2 with ${ \bf X } = { \bf X } _ { i n } ^ { \prime }$ and the designed $r ( \mathcal { C } , \mathbf { F } , \mathcal { G } )$ . To demonstrate the potential of UGNN, next we introduce a new GNN model ADA-UGNN by instantiating UGNN with $r ( \mathcal { C } , \mathbf { F } , \mathcal { G } )$ enforcing adaptive local smoothness across nodes. Note that we introduce ADA-UGNN with node classification as the downstream task.
+
+# 5 ADA-UGNN: ADAPTIVE LOCAL SMOOTHING WITH UGNN
+
+From the graph signal denoising perspective, PPNP, APPNP, and GCN enforces global smoothness by penalizing the difference with a constant $\mathcal { C }$ for all nodes. However, real-world graphs may consist of multiple groups of nodes which have different behaviors in connecting to similar neighbors. For example, Section 6.1 shows several graphs with varying distributions of local smoothness (as measured by label homophily): summarily, not all nodes are highly label-homophilic, and some nodes have considerably “noisier” neighborhoods than others. Moreover, as suggested by Wu et al. (2019); Jin et al. (2020), adversarial attacks on graphs tend to promote such label noise in graphs by connecting nodes from different classes and disconnecting nodes from the same class, rendering resultant graphs with varying local smoothness across nodes. Under these scenarios, a constant $\mathcal { C }$ might not be optimal and adaptive (i.e. non-constant) smoothness to different nodes is desired. As shown in Section 3.3 by viewing GAT’s aggregation as a solution to regularized graph signal denoising, GAT can be regarded as adopting an adaptive $\mathcal { C }$ for different nodes, which facilitates adaptive local smoothness. However, in GAT, the graph denoising problem is solved by a single step of gradient descent, which might still be suboptimal. Furthermore, when modeling the local smoothness factor $c _ { i }$ in Eq. (17), GAT only uses features of node $i$ as input, which may not be optimal since by understanding $c _ { i }$ as local smoothness, it should be intrinsically related to the neighborhood of node $i$ . In this section, we adapt this notion directly into the UGNN framework by introducing a new regularization term, and develop a resulting GNN model (ADA-UGNN) which aims to enforce adaptive local smoothness to nodes in a different manner to GAT. We then utilize an iterative gradient descent method to approximate the optimal solution for Problem 2 with the following regularization term:
+
+$$
+r ( \mathcal { C } , \mathbf { F } , \mathcal { G } ) = \frac { 1 } { 2 } \cdot \sum _ { i \in \mathcal { V } } \mathcal { C } _ { i } \sum _ { j \in \tilde { \mathcal { N } } ( i ) } \left\| \frac { \mathbf { F } [ i , : ] } { \sqrt { d _ { i } } } - \frac { \mathbf { F } [ j , : ] } { \sqrt { d _ { j } } } . \right\| _ { 2 } ^ { 2 }
+$$
+
+where $d _ { i } , d _ { j }$ denotes the degree of node $i$ and $j$ respectively, and $\mathcal { C } _ { i }$ indicates the smoothness factor of node $i$ , which is assumed to be a fixed scalar. Note that, the above regularization term can be regarded as a generalized version of the regularization term used in PPNP, APPNP, and GCN. Similar to PPNP and APPNP, ADA-UGNN only consists of a single GNN layer. However, ADA-UGNN assumes adaptive local smoothness. We next describe the feature transformation and aggregation operations of ADA-UGNN, and show how to derive the model via UGNN.
+
+# 5.1 FEATURE TRANSFORMATION
+
+Similar to PPNP and APPNP, we adopt MLP for the feature transformation. Specifically, for a node classification task, the dimension of the output of the feature transformation $\mathbf { \bar { X } } _ { i n } ^ { \prime }$ is the number of classes in the graph.
+
+# 5.2 FEATURE AGGREGATION
+
+We use iterative gradient descent to solve Problem 2 with the regularization term in Eq. (22) The iterative gradient descent steps are stated in the following theorem and its proof can be found at Appendix A.1.
+
+Theorem 5. With adaptive stepsize $b _ { i } = 1 / \left( 2 + \sum _ { j \in \tilde { \mathcal { N } } ( i ) } ( \mathcal { C } _ { i } + \mathcal { C } _ { j } ) / d _ { i } \right)$ for each node i, the iterative gradient descent steps to solve Problem 2 with the regularization term in Eq. (22) is as follows:
+
+$$
+\mathbf { F } ^ { ( k ) } [ i , : ]  2 b \mathbf { X } [ i , : ] + b _ { i } \sum _ { j \in \tilde { \cal N } ( i ) } ( \mathcal { C } _ { i } + \mathcal { C } _ { i } ) \frac { \mathbf { F } ^ { ( k - 1 ) } [ j , : ] } { \sqrt { d _ { i } d _ { j } } } ; \quad k = 1 , \dots .
+$$
+
+where ${ \bf F } ^ { ( 0 ) } [ i , : ] = { \bf X } [ i , : ]$
+
+The iterative steps in Eq. (23) is guaranteed for convergence as stated in the following theorem and its proof can be found in Appendix A.2.
+
+Theorem 6. The iterative steps in Eq. (23) is guaranteed to converge to the optimal solution of Problem 2 with Eq. (22) as regularization term.
+
+Following the iterative solution in Eq. (23), we model the aggregation operation (for node $i$ ) for ADA-UGNN as follows:
+
+$$
+{ \bf X } _ { o u t } ^ { ( k ) } [ i , : ]  2 b _ { i } { \bf X } _ { i n } ^ { \prime } [ i , : ] + b _ { i } \sum _ { v _ { j } \in \tilde { \cal N } ( v _ { i } ) } ( \mathcal { C } _ { i } + \mathcal { C } _ { j } ) \frac { { \bf X } _ { o u t } ^ { ( k - 1 ) } [ j , : ] } { \sqrt { d _ { i } d _ { j } } } ; \quad k = 1 , \dots K ,
+$$
+
+where $K$ is the number gradient descent iterations, $\mathcal { C } _ { i }$ can be considered as a positive scalar to control the level of “local smoothness” for node $i$ and $b _ { i }$ can be calculated from $\bar { \{ { \mathcal C } _ { j } | j }  \in \tilde { \mathcal { N } } ( i ) \}$ as $b _ { i } = 1 / \left( 2 + \sum _ { j \in \tilde { \mathcal { N } } ( i ) } ( \mathcal { C } _ { i } + \mathcal { C } _ { j } ) / d _ { i } \right)$ . However, in practice, $\mathcal { C } _ { i }$ is usually unknown. One possible solution is to treat $\mathcal { C } _ { i }$ as hyper-parameters. Treating $\mathcal { C } _ { i }$ as hyper-parameters for all nodes is impractical, since there are, in total $N$ of them and we do not have their prior knowledge. Thus, we model $\mathcal { C } _ { i }$ as a function of the information of the neighborhood of node $i$ as follows:
+
+$$
+\mathcal { C } _ { i } = s \cdot \sigma \left( h _ { 1 } \left( h _ { 2 } \left( \left\{ \mathbf { X } _ { i n } ^ { \prime } [ j , : ] | j \in \tilde { N } ( i ) \right\} \right) \right) \right) ,
+$$
+
+where $h _ { 2 } ( \cdot )$ is a function to transform the neighborhood information of node $i$ to a vector, while $h _ { 1 } ( \cdot )$ further transforms it to a scalar. $\sigma ( \cdot )$ denotes the sigmoid function, which maps the output scalar from $h _ { 1 } ( \cdot )$ to $( 0 , 1 )$ and $s$ can be treated as a hyper-parameter controlling the upper bound of $\mathcal { C } _ { i }$ . $h _ { 1 } ( \cdot )$ can be modeled as a single layer fully-connected neural network. There are different designs for $h _ { 2 } ( \cdot )$ such as channel-wise variance or mean (Corso et al., 2020). In this paper, we adopt channel-wise variance as the $h _ { 2 } ( \cdot )$ function. In this case, the calculation of $\mathcal { C } _ { i }$ in Eq. (25) only involves $H$ parameters, with $H$ denoting number of classes in the dataset. APPNP can be regarded a special case of ADA-UGNN, where $\bar { h _ { 2 } } ( \cdot )$ is modeled as a constant function producing 1 as the outpafter for all nodes. For the node classification task, the representation iterations as in Eq. (24), is directly softmax normalized row-wise $\mathbf { X } _ { o u t } ^ { ( K ) }$ ,s hich is obtained-th row indicates $K$ $i$ the discrete class distribution of node $i$ .
+
+# 6 EXPERIMENT
+
+In this section, we evaluate how the proposed ADA-UGNN handles graphs with varying local smoothness. We conduct node classification experiments on natural graphs, and also evaluate the model’s robustness under adversarial attacks. We note that our main goal in proposing/evaluating ADA-UGNN is to demonstrate the promise of deriving new aggregations as solutions of denoising problems, rather than state-of-the-art performance.
+
+# 6.1 NODE CLASSIFICATION
+
+In this section, we conduct the node classification task. We first introduce the datasets and the experimental settings in Section 6.1.1 and then present the results in Section 6.1.2.
+
+# 6.1.1 DATASETS AND EXPERIMENTAL SETTINGS
+
+We conduct the node classification task on 8 datasets from various domains including citation, social, co-authorship and co-purchase networks. Specifically, we use three citation networks including CORA, CITESEER, and PUBMED (Sen et al., 2008); one social network, BLOGCATALOG (Huang et al., 2017); two co-authorship networks including COAUTHOR-CS and COAUTHOR-PH (Shchur et al., 2018); and two co-purchase networks including AMAZON-COMP and Amazon Photos (Shchur et al., 2018). Descriptions and detail statistics about these datasets can be found in Appendix C.1. To provide a sense of the local smoothness properties of these datasets, in addition to the summary statistics, we also illustrate the local label smoothness distributions in Appendix C.1.1: here, we define the local label smoothness of a node as the ratio of nodes in its neighborhood that share the same label (see formal definition in Eq. (34) in Appendix C.1.1). Notably, the variety in local label smoothness within several real-world datasets – also observed in (Shah, 2020) – clearly motivates the importance of the adaptive smoothness assumption in ADA-UGNN. For the citation networks, we use the standard split as provided in Kipf & Welling (2016); Yang et al. (2016). For BLOGCATALOG, we adopt the split provided in Zhao et al. (2020). For both the citation networks and BLOGCATALOG, the experiments are run with 30 random seeds and the average results are reported. For co-authorship and co-purchase networks, we utilize 20 labels per class for training, 30 nodes per class for validation and the remaining nodes for test. This process is repeated 20 times, which results in 20 different training/validation/test splits. For each split, the experiment is repeated for 20 times with different initialization. The average results over $2 0 \times 2 0$ experiments are reported. We compare our methods with the methods introduced in Section 2 including GCN, GAT and APPNP. Note that we do not include PPNP as it is difficult to scale for most of the datasets due to the calculation of inverse in Eq. 6. For all methods, we tune the hyperparameters from the following options: 1) learning rate: $\{ 0 . 0 0 \dot { 5 } , 0 . 0 1 , 0 . 0 5 \} ;$ 2) weight decay $\{ 5 e - 0 \dot { 4 } , 5 e - 0 5 , 5 e - 0 6 , 5 e - 0 7 , 5 e - 0 \dot { 8 } \}$ ; and 3) dropout rate: $\{ 0 . 2 , 0 . 5 , 0 . 8 \}$ . For APPNP and our method we further tune the number of iterations $K$ and the upper bound $s$ for $c _ { i }$ in Eq. (25) from the following range: 1) $K$ : $\{ 5 , 1 0 \}$ ; and $s$ : $\{ 1 , 9 , 1 9 \}$ . Note that we treat APPNP as a special case of our proposed method with $\overset { \cdot } { h _ { 2 } } ( \cdot ) = 1$ .
+
+# 6.1.2 PERFORMANCE COMPARISON
+
+The performance comparison is shown in Table 1, where $t$ -test is used to test the significance. First, GAT outperforms GCN in most datasets. It indicates that modeling adaptive local smoothness is helpful. Second, APPNP/ADA-UGNN outperform GCN/GAT in most settings, suggesting that iterative gradient descent may offer advantages to single-step gradients, due to their better ability to achieve a solution closer to the optimal. Third, and most notably, the proposed ADA-UGNN achieves consistently better performance than GCN/GAT, and outperforms or matches the stateof-the-art APPNP across datasets. Notice that in some datasets such as CORA, CITESEER, and
+
+Table 1: Node Classification Accuracy on Various Datasets   
+
+<table><tr><td>Dataset</td><td>GCN</td><td>GAT</td><td>APPNP</td><td>ADA-UGNN</td></tr><tr><td>CORA</td><td>81.75±0.8</td><td>82.56±0.8</td><td>84.49±0.6</td><td>84.59±0.8*</td></tr><tr><td>CITESEER</td><td>70.13±1.0</td><td>70.77±0.8</td><td>71.97±0.6</td><td>72.05±0.5</td></tr><tr><td>PUBMED</td><td>78.56±0.5</td><td>78.88±0.5</td><td>79.92±0.5</td><td>79.70±0.4</td></tr><tr><td>BLOGCATALOG</td><td>71.38±2.7</td><td>72.90±1.2</td><td>92.43±0.9</td><td>93.33±0.3***</td></tr><tr><td>AMAZON-COMP</td><td>82.79±1.3</td><td>83.01±1.5</td><td>82.99±1.6</td><td>83.40±1.3***</td></tr><tr><td>AMAZON-PHOTO</td><td>89.60±1.5</td><td>90.33±1.2</td><td>91.38±1.2</td><td>91.44±1.2</td></tr><tr><td>COAUTHOR-CS</td><td>91.55±0.6</td><td>90.95±0.7</td><td>91.69±0.4</td><td>92.33±0.5***</td></tr><tr><td>COAUTHOR-PH</td><td>93.23±0.7</td><td>92.86±0.7</td><td>93.84±0.5</td><td>93.92±0.6**</td></tr></table>
+
+∗, $^ { \ast \ast }$ , $^ { \ast \ast \ast }$ indicate the improvement over APPNP is significant at $\overline { { p < 0 . 1 , 0 . 0 5 } }$ and 0.005
+
+![](images/a400fb3808392892e1db0ed049b1e5da8e0459b5360725961d2a3d39af1187ce.jpg)  
+Figure 1: Accuracy for nodes with low and high local label smoothness.
+
+COAUTHOR-PH, the improvements of the proposed model compared with APPNP are not very significant. Figure 3 in Appendix C.1.1 shows that these datasets have extremely skewed local label smoothness distributions, with the majority of nodes having perfect, 1.0, label homophily (they are only connected to other nodes of the same label). APPNP shines in such cases, since its assumption of $h _ { 2 } ( \cdot ) = 1$ is ideal for these nodes (designating maximal local smoothness). Conversely, our model has the challenging task of learning $h _ { 2 } ( \cdot )$ – in such skewed cases, learning $h _ { 2 } ( \cdot )$ may be quite challenging and unfruitful. On the other hand, for datasets with higher diversity in local label smoothness across nodes such as BLOGCATALOG and AMAZON-COMP, the proposed ADA-UGNN achieves more significant improvements.
+
+To further validate, we partition the nodes in the test set of each dataset into two groups: (1) high smoothness: those with local label smoothness $> 0 . 5$ , and (2) low smoothness: those with $\le 0 . 5$ , and evaluate accuracy for APPNP and the proposed ADA-UGNN for each group. The results for CORA, BLOGCATALOG, AMAZON-COMP and COAUTHOR-CS are presented in Figure 1 while the results for the remaining datasets can be found in Figure 4 in Appendix C.2. Figure 1 clearly shows that ADA-UGNN consistently improves performance for low-smoothness nodes in most datasets, while keeping comparable (or marginally worse) performance for high-smoothness nodes. In cases where many nodes have low-level smoothness (like BLOGCATALOG or AMAZON-COMP), our method can notably improve overall performance.
+
+# 6.2 ROBUSTNESS UNDER ADVERSARIAL ATTACKS
+
+Adversarial attacks on graphs tend to connect nodes from different classes and remove edges between nodes from the same class (Wu et al., 2019; Jin et al., 2020), producing graphs with varying local label smoothness after attack (we demonstrate this in Appendix C.3). To further demonstrate that ADA-UGNN can handle graphs with varying local label smoothness better than alternatives, we conduct experiments to show its robustness under adversarial attacks. Specifically, we adopt Mettack (Zugner & G ¨ unnemann ¨ , 2019) to perform the attacks. Mettack produces non-targeted attacks which aim to impair test set node classification performance by strategically adding or removing edges from the victim graph. We utilize the attacked graphs $( 5 \% - 2 5 \%$ perturb rate) from Jin et al. (2020) and follow the same setting, i.e., each method is run with 10 random seeds and the average performance is reported. These attacked graphs are generated from CORA, CITESEER and PUBMED, respectively and only the largest connected component is retained in each graph. Furthermore, the training, validation and test split ratio is $1 0 / 1 0 \dot { / } 8 0 \%$ , which is different from the standard splits we use in Section 6.1. Thus, the performances reported in this section is not directly comparable with those in the previous section. We compare our method both with standard GNNs discussed in Section 2 (GCN, GAT, APPNP), but also with recent state-of-the-art defense techniques against adversarial attacks including GCN-Jaccard (Wu et al., 2019), GCN-SVD (Entezari et al., 2020), ProGNN-fs and Pro-GNN (Jin et al., 2020). The detailed description of these methods can be found at
+
+![](images/f74d1103908e4a1b446a00caca193a6ff67345a6aa86b5672d5f8a6724a557c6.jpg)  
+Figure 2: Robustness under adversarial attacks (node classification accuracy).
+
+Appendix C.4. Results under varying perturbation rates (attack intensities) are shown in Figure 2. Again, we observe that GAT outperforms GCN, suggesting the appeal of an adaptive local smoothness assumption. Here, our method (orange) substantially outperforms GCN, GAT and APPNP by a large margin, especially in scenarios with high perturbation rate. Moreover, the proposed ADAUGNN is also even more robust than several specially designed adversarial defense methods, like GCN-Jaccard and GCN-SVD, which are based on pre-processing the adversarial attack graphs to obtain cleaner ones, thanks to its adaptive smoothness assumption. Compared with Pro-GNN-fs, our method performs comparably or even better in a few settings, especially when perturbation rate is high. Furthermore, in these settings, the performance of our method is even closer to ProGNN, which is the current state-of-the art adversarial defense technique. Note that, Pro-GNN-fs and Pro-GNN involves learning cleaner adjacency matrices of the attacked graphs, and thus has $O ( M )$ parameters (M denotes the number of edges in a graph), while our proposed model has far less parameters. Specifically, we have $O ( d _ { i n } \cdot \bar { d _ { o u t } } )$ for feature transformation and $H$ parameters for modelling $h _ { 1 } ( \cdot )$ with $H$ denoting the number of labels.
+
+# 7 RELATED WORKS
+
+There are mainly two streams of work in developing GNN models, i.e, spectral-based and spatialbased. When designing spectral-based GNNs, graph convolution (Shuman et al., 2013), defined based on spectral theory, is utilized to design graph neural network layers together with the feature transformation and non-linearity (Bruna et al., 2013; Henaff et al., 2015; Defferrard et al., 2016). These designs of the spectral-based graph convolution are tightly related with graph signal processing, and they can be regarded as graph filters. Low-pass graph filters can usually be adopted to denoise graph signals (Chen et al., 2014). In fact, most algorithms discussed in our work can be regarded as low-pass graph filters. With the emergence of GCN (Kipf & Welling, 2016), which can be regarded as a simplified spectral-based and also a spatial-based graph convolution operator, numerous spatial-based GNN models have since been developed (Hamilton et al., 2017; Velickovi ˇ c´ et al., 2017; Monti et al., 2017; Gao et al., 2018; Gilmer et al., 2017).
+
+Graph signal denoising is to infer a cleaner graph signal given a noisy signal, and can be usually formulated as a graph regularized optimization problem (Chen et al., 2014). Recently, several works connect GCN with graph signal denoising with Laplacian regularization (NT & Maehara, 2019; Zhao & Akoglu, 2019), where they found the aggregation process in GCN models can be regarded as the first-order approximation of the optimal solution of the denoising problem. On the other hand, GNNs are also utilized to develop novel algorithms for graph denoising (Chen et al., 2020). Unlike these works, our paper details how a family of GNN models can be unified with a graph signal denoising perspective, and demonstrates its promise for new architecture design.
+
+# 8 CONCLUSION
+
+In this paper, we show how various representative GNN models including GCN, PPNP, APPNP and GAT can be unified mathematically as natural instances of graph denoising problems. Specifically, the aggregation operations in these models can be regarded as exactly or approximately addressing such denoising problems subject to Laplacian regularization. With these observations, we propose a general framework, UGNN, which enables the design of new GNN models from the denoising perspective via regularizer design. As an example demonstrating the promise of this paradigm, we instantiate the UGNN framework with a regularizer addressing adaptive local smoothness across nodes, a property prevalent in several real-world graphs, and proposed and evaluated a suitable new GNN model, ADA-UGNN.
+
+# REFERENCES
+
+Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. arXiv preprint arXiv:1312.6203, 2013.
+
+Siheng Chen, Aliaksei Sandryhaila, Jose MF Moura, and Jelena Kovacevic. Signal denoising on ´ graphs via graph filtering. In 2014 IEEE Global Conference on Signal and Information Processing (GlobalSIP), pp. 872–876. IEEE, 2014.
+
+Siheng Chen, Yonina C Eldar, and Lingxiao Zhao. Graph unrolling networks: Interpretable neural networks for graph signal denoising. arXiv preprint arXiv:2006.01301, 2020.
+
+Gabriele Corso, Luca Cavalleri, Dominique Beaini, Pietro Lio, and Petar Veli \` ckovi ˇ c. Principal ´ neighbourhood aggregation for graph nets. arXiv preprint arXiv:2004.05718, 2020.
+
+Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on ¨ graphs with fast localized spectral filtering. In Advances in neural information processing systems, pp. 3844–3852, 2016.
+
+Negin Entezari, Saba A Al-Sayouri, Amirali Darvishzadeh, and Evangelos E Papalexakis. All you need is low (rank) defending against adversarial attacks on graphs. In Proceedings of the 13th International Conference on Web Search and Data Mining, pp. 169–177, 2020.
+
+Hongyang Gao, Zhengyang Wang, and Shuiwang Ji. Large-scale learnable graph convolutional networks. In Proceedings of the 24th ACM SIGKDD, pp. 1416–1424, 2018.
+
+Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. arXiv preprint arXiv:1704.01212, 2017.
+
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In NeurIPS, pp. 1024–1034, 2017.
+
+Mikael Henaff, Joan Bruna, and Yann LeCun. Deep convolutional networks on graph-structured data. arXiv preprint arXiv:1506.05163, 2015.
+
+Xiao Huang, Jundong Li, and Xia Hu. Label informed attributed network embedding. In Proceedings of the Tenth ACM International Conference on Web Search and Data Mining, pp. 731–739, 2017.
+
+Wei Jin, Yao Ma, Xiaorui Liu, Xianfeng Tang, Suhang Wang, and Jiliang Tang. Graph structure learning for robust graph neural networks. arXiv preprint arXiv:2005.10203, 2020.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.
+
+Johannes Klicpera, Aleksandar Bojchevski, and Stephan Gunnemann. Predict then propagate: ¨ Graph neural networks meet personalized pagerank. arXiv preprint arXiv:1810.05997, 2018.
+
+Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodola, Jan Svoboda, and Michael M Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. In Proceedings of the IEEE Conference on CVPR, pp. 5115–5124, 2017.
+
+Yurii Nesterov. Introductory lectures on convex optimization: A basic course, volume 87. Springer Science & Business Media, 2013.
+
+Hoang NT and Takanori Maehara. Revisiting graph neural networks: All we have is low-pass filters. arXiv preprint arXiv:1905.09550, 2019.
+
+Yu Rong, Wenbing Huang, Tingyang Xu, and Junzhou Huang. Dropedge: Towards deep graph convolutional networks on node classification. In International Conference on Learning Representations, 2019.
+
+Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3):93–93, 2008.
+
+Neil Shah. Scale-free, attributed and class-assortative graph generation to facilitate introspection of graph neural networks. KDD Mining and Learning with Graphs, 2020.
+
+Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Gunnemann. Pitfalls ¨ of graph neural network evaluation. arXiv preprint arXiv:1811.05868, 2018.
+
+David I Shuman, Sunil K Narang, Pascal Frossard, Antonio Ortega, and Pierre Vandergheynst. The emerging field of signal processing on graphs: Extending high-dimensional data analysis to networks and other irregular domains. IEEE signal processing magazine, 30(3):83–98, 2013.
+
+Ryan J Tibshirani et al. Adaptive piecewise polynomial estimation via trend filtering. The Annals of Statistics, 42(1):285–323, 2014.
+
+Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017.
+
+Yu-Xiang Wang, James Sharpnack, Alexander J Smola, and Ryan J Tibshirani. Trend filtering on graphs. The Journal of Machine Learning Research, 17(1):3651–3691, 2016.
+
+Huijun Wu, Chen Wang, Yuriy Tyshetskiy, Andrew Docherty, Kai Lu, and Liming Zhu. Adversarial examples on graph data: Deep insights into attack and defense. arXiv preprint arXiv:1903.01610, 2019.
+
+Zhilin Yang, William Cohen, and Ruslan Salakhudinov. Revisiting semi-supervised learning with graph embeddings. In International conference on machine learning, pp. 40–48. PMLR, 2016.
+
+Rex Ying, Ruining He, Kaifeng Chen, Pong Eksombatchai, William L Hamilton, and Jure Leskovec. Graph convolutional neural networks for web-scale recommender systems. In Proceedings of the 24th ACM SIGKDD, pp. 974–983, 2018a.
+
+Zhitao Ying, Jiaxuan You, Christopher Morris, Xiang Ren, Will Hamilton, and Jure Leskovec. Hierarchical graph representation learning with differentiable pooling. In Advances in neural information processing systems, pp. 4800–4810, 2018b.
+
+Lingxiao Zhao and Leman Akoglu. Pairnorm: Tackling oversmoothing in gnns. arXiv preprint arXiv:1909.12223, 2019.
+
+Tong Zhao, Yozen Liu, Leonardo Neves, Oliver Woodford, Meng Jiang, and Neil Shah. Data augmentation for graph neural networks. arXiv preprint arXiv:2006.06830, 2020.
+
+Daniel Zugner and Stephan G ¨ unnemann. Adversarial attacks on graph neural networks via meta ¨ learning. arXiv preprint arXiv:1902.08412, 2019.
+
+# A PROOFS
+
+A.1 PROOF OF THEOREM 5
+
+Theorem 5. With adaptive stepsize $b _ { i } = 1 / \left( 2 + \sum _ { v _ { j } \in \tilde { \mathcal { N } } ( v _ { i } ) } ( \mathcal { C } _ { i } + \mathcal { C } _ { j } ) / d _ { i } \right)$ for each node $v _ { i }$ , the iterative gradient descent steps to solve Problem 2 with the regularization term in Eq. (22) is as follows:
+
+$$
+\mathbf { F } ^ { ( k ) } [ i , : ] \longleftarrow 2 b \mathbf { X } [ i , : ] + b _ { i } \sum _ { v _ { j } \in \tilde { N } ( v _ { i } ) } ( \mathcal { C } _ { i } + \mathcal { C } _ { i } ) \frac { \mathbf { F } ^ { ( k - 1 ) } [ j , : ] } { \sqrt { d _ { i } d _ { j } } } ; \quad k = 1 , \dots
+$$
+
+where ${ \bf F } ^ { ( 0 ) } [ i , : ] = { \bf X } [ i , : ]$ .
+
+Proof. The gradient of the optimization problem 2 with the regularization term in Eq. (22) with respect to $\mathbf { F }$ (focusing on node $i$ ) is as follows:
+
+$$
+\frac { \partial \mathcal { L } } { \partial \mathbf { F } [ i , : ] } = 2 ( \mathbf { F } [ i , : ] - \mathbf { X } [ i , : ] ) + \sum _ { v _ { j } \in \tilde { \mathcal { N } } ( v _ { i } ) } \frac { \mathcal { C } _ { i } + \mathcal { C } _ { j } } { \sqrt { d _ { i } } } \left( \frac { \mathbf { F } [ i , : ] } { \sqrt { d _ { i } } } - \frac { \mathbf { F } [ j , : ] } { \sqrt { d _ { j } } } \right) ,
+$$
+
+where $\mathcal { C } _ { j }$ in the second term appears since node $i$ is also in the neighborhood of node $j$ . The iterative gradient descent steps with adaptive stepsize $b _ { i }$ can be formulated as follows:
+
+$$
+\mathbf { F } ^ { ( k ) } [ i , : ]  \mathbf { F } ^ { ( k - 1 ) } [ i , : ] - b _ { i } \cdot  \frac { \partial \mathcal { L } } { \partial \mathbf { F } [ i , : ] } | _ { \mathbf { F } [ i , : ] = \mathbf { F } ^ { ( k - 1 ) } [ i , : ] } ; \quad k = 1 , \dots .
+$$
+
+With the gradient in Eq. (27), the iterative steps in Eq. (28) can be rewritten as:
+
+$$
+\begin{array} { c } { { { \bf F } ^ { ( k ) } [ i , : ]  ( 1 - 2 b _ { i } - b _ { i } \displaystyle \sum _ { v _ { j } \in \tilde { \mathcal { N } } ( v _ { i } ) } \frac { \mathcal { C } _ { i } + \mathcal { C } _ { j } } { d _ { i } } ) { \bf F } ^ { ( k - 1 ) } [ i , : ] + 2 b _ { i } { \bf X } [ i , : ] } } \\ { { + b _ { i } \displaystyle \sum _ { v _ { j } \in \tilde { \mathcal { N } } ( v _ { i } ) } ( \mathcal { C } _ { i } + \mathcal { C } _ { j } ) \frac { { \bf F } ^ { ( k ) } [ j , : ] } { \sqrt { d _ { i } d _ { j } } } ; \quad k = 1 , . . . } } \end{array}
+$$
+
+Given $b _ { i } = 1 / \left( 2 + \sum _ { v _ { j } \in \tilde { \mathcal { N } } ( v _ { i } ) } ( \mathcal { C } _ { i } + \mathcal { C } _ { j } ) / d _ { i } \right)$ , the iterative steps in Eq. (29) can be re-written as follows:
+
+$$
+\mathbf { F } ^ { ( k ) } [ i , : ]  2 b \mathbf { X } [ i , : ] + b _ { i } \sum _ { v _ { j } \in \tilde { \cal N } ( v _ { i } ) } ( \mathcal { C } _ { i } + \mathcal { C } _ { j } ) \frac { \mathbf { F } ^ { ( k - 1 ) } [ j , : ] } { \sqrt { d _ { i } d _ { j } } } ; \quad k = 1 , \dots ,
+$$
+
+with ${ \bf F } ^ { ( 0 ) } [ i , : ] = { \bf X } [ i , : ]$ , which completes the proof.
+
+# A.2 PROOF OF THEOREM 6
+
+Theorem 6. The iterative steps in Eq. (23) is guaranteed to converge to the optimal solution of Problem 2 with Eq. (22) as regularization term.
+
+Proof. By taking the second derivative with respect to $\mathbf { F } [ i , : ]$ , we obtain the Hessian matrix as:
+
+$$
+\frac { \partial \mathcal { L } ^ { 2 } } { \partial \mathbf { F } [ i , : ] ^ { 2 } } = 2 \mathbf { I } + \sum _ { v _ { j } \in \tilde { \mathcal { N } } ( v _ { i } ) } ( \frac { \mathcal { C } _ { i } + \mathcal { C } _ { j } } { d _ { i } } ) \mathbf { I }
+$$
+
+which implies the Lipschitz constant of the gradient in Eq. (27) is $2 + \sum _ { v _ { j } \in \tilde { \mathcal { N } } ( v _ { i } ) } ( \frac { \mathcal { C } _ { i } + \mathcal { C } _ { j } } { d _ { i } } )$ . To guarantee convergence, the stepsize $b _ { i }$ for node $i$ should be smaller than $2 / \left( 2 + \sum _ { v _ { j } \in \tilde { \mathcal { N } } ( i ) } ( \mathcal { C } _ { i } + \mathcal { C } _ { j } ) / d _ { i } \right)$ (Nesterov, 2013). The stepsize we adopt in Theorem 5 is $b _ { i } = 1 / \left( 2 + \sum _ { j \in \tilde { \mathcal { N } } ( i ) } ( \mathcal { C } _ { i } + \mathcal { C } _ { j } ) / d _ { i } \right)$ , hence the convergence is guaranteed.
+
+# B CONNECTIONS TO PAIRNORM AND DROPEDGE
+
+PairNorm and DropEdge, which are two recently proposed GNN enhancements for developing deeper GNN models, are corresponding to the following regularization terms:
+
+$$
+\mathrm { P a i r N o r m : } \ : \ : \sum _ { ( i , j ) \in \mathcal { E } } \ : \mathcal { C } _ { p } \cdot \| \mathbf { F } [ i , : ] - \mathbf { F } [ j , : ] \| _ { 2 } ^ { 2 } - \ : \sum _ { ( i , j ) \notin \mathcal { E } } \ : \mathcal { C } _ { n } \cdot \| \mathbf { F } [ i , : ] - \mathbf { F } [ j , : ] \| _ { 2 } ^ { 2 } ,
+$$
+
+$$
+\sum _ { ( i , j ) \in \mathcal { E } } \mathcal { C } _ { i j } \cdot \Vert \mathbf { F } [ i , : ] - \mathbf { F } [ j , : ] \Vert _ { 2 } ^ { 2 } , \mathrm { ~ w h e r e ~ } \mathcal { C } _ { i j } \in \{ 0 , 1 \} .
+$$
+
+For PairNorm, $\mathcal { C }$ consists of $\mathcal { C } _ { p } , \mathcal { C } _ { n } > 0$ and the regularization term ensures connected nodes to be similar while disconnected nodes to be dissimilar. For DropEdge, $\mathcal { C }$ is a sparse matrix having the same shape as adjacency matrix. For each edge $( i , j )$ , its corresponding $\mathcal { C } _ { i j }$ is sampled from a Bernoulli distribution with mean $1 - q$ , where $q$ is a pre-defined dropout rate.
+
+# C EXPERIMENTS
+
+# C.1 DATASETS
+
+Table 2: Dataset summary statistics.   
+
+<table><tr><td></td><td>#Nodes</td><td>#Edges</td><td>#Labels</td><td>#Features</td></tr><tr><td>CORA</td><td>2708</td><td>13264</td><td>7</td><td>1433</td></tr><tr><td>CITESEER</td><td>3327</td><td>12431</td><td>6</td><td>3703</td></tr><tr><td>PUBMED</td><td>19717</td><td>108365</td><td>3</td><td>500</td></tr><tr><td>BLOGCATALOG</td><td>5196</td><td>348682</td><td>6</td><td>8189</td></tr><tr><td>AMAZON-COMP</td><td>13381</td><td>504937</td><td>10</td><td>767</td></tr><tr><td>AMAZON-PHOTO</td><td>7487</td><td>245573</td><td>8</td><td>745</td></tr><tr><td>COAUTHOR-CS</td><td>18333</td><td>182121</td><td>15</td><td>6805</td></tr><tr><td>COAUTHOR-PH</td><td>34493</td><td>530417</td><td>5</td><td>8415</td></tr></table>
+
+In this section, we provide information of the datasets we used in the experiments as follows:
+
+• Citation Networks: CORA, CITESEER and PUBMED are widely adopted benchmarks of GNN models. In these graphs, nodes represent documents and edges denote the citation links between them. Each node is associated bag-of-words features of its corresponding document and also a label indicating the research field of the document.
+
+• Blogcatalog: BLOGCATALOG is an online blogging community where bloggers can follow each other. The BLOGCATALOG graph consists of blogger as nodes while their social relations as edges. Each blogger is associated with some features generated from key words of his/her blogs. The bloggers are labeled according to their interests.
+
+• Co-purchase Graph: AMAZON-COMP and AMAZON-PHOTO are co-purchase graphs, where nodes represent items and edges indicate that two items are frequently bought together. Each item is associated with bag-of-words features extract from its corresponding reviews. The labels of items are given by the category of them.
+
+• Co-authorship Graphs: COAUTHOR-CS and COAUTHOR-PH are co-authorship graphs, where nodes are authors and edges indicating the co-authorship between authors. Each author is associated with some features representing the keywords of his/her papers. The label of an author indicates the his/her most active research field.
+
+Some statistics of these graphs are shown in Table 2.
+
+# C.1.1 LOCAL LABEL SMOOTHNESS OF DATASETS
+
+We further present the distribution of local label smoothness in these datasets. For a node $v _ { i }$ we formally define the local label smoothness as follows
+
+$$
+\mathbf { l s } ( i ) = \frac { \displaystyle \sum _ { j \in \mathcal { N } ( i ) } \mathbf { 1 } \{ l ( i ) = l ( j ) \} } { | \mathcal { N } ( i ) | }
+$$
+
+![](images/953079b281d0ece9b0133c1aa6ea60773a2a265341c18580262cb3139c485f5e.jpg)  
+Figure 3: Distribution of local label smoothness (homophily) on different graph datasets: note the non-homogeneity of smoothness values.
+
+![](images/8a5cb3da8f532fef7ab7e4600bfc67abd25fb92336c30c0044d163f9e2f1ed64.jpg)  
+Figure 4: Accuracy with low label smoothness and high label smoothness nodes. Note the consistent improvement in low smoothness cases, enabled by adaptive local smoothing.
+
+where $l ( v _ { i } )$ denotes the label of node $v _ { i }$ and ${ \bf 1 } \{ a \}$ is an indicator function, which takes 1 as output only when $a$ is true, otherwise 0. The distributions of local label smoothness for all 8 datasets are presented in Figure 3.
+
+C.2 NODE CLASSIFICATION ACCURACY FOR NODES WITH LOW-LEVEL AND HIGH-LEVEL LOCAL LABEL SMOOTHNESS
+
+The performance of nodes with low local label smoothness and high local label smoothness in CITESEER, PUBMED, AMAZON-PHOTO and COAUTHOR-PH are presented in Figure 4.
+
+# C.3 LOCAL SMOOTHNESS DISTRIBUTION OF ATTACKED GRAPH
+
+Graph adversarial attacks tend to connect nodes from different classes while disconnect nodes from the same class, which typically leads to more diverse distributions of local smoothness level. We present the distributions of the graphs generated by Mettack (Zugner & G ¨ unnemann ¨ , 2019) with different perturbation rate for CORA, CITESEER and PUBMED in Figure 5, Figure 6 and Figure 7, respectively.
+
+# C.4 BASELINES FOR ADVERSARIAL DEFENSE
+
+In this section, we list the descriptions of the defense algorithms we adopt in Section 6.2 as follows:
+
+• GCN-Jaccard (Wu et al., 2019): GCN-Jaccard aims to pre-process a given attacked graph by removing those edges added by the attackers. Specifically, Jaccard smilarlity is utilized to measure the feature similarity between connected pairs of nodes. The edges between node pairs with low-similarity are removed by the algorithm. This pre-processed graph is then utilized for the node classification task.
+
+![](images/0f393ec89df9e3adf2a569997731130e51bb9738d49ee593ac53114fc29809b9.jpg)  
+Figure 5: Distribution of local label smoothness on CORA with various attack perturbation rates.
+
+![](images/2024bc0ffce3caf6534ff9a3191530b08ee4a316329a13fe5446ae76ea2e5c20.jpg)  
+Figure 6: Distribution of local label smoothness on CITESEER with various attack perturbation rates.
+
+![](images/c9279d36c6858fba803c7b45af8ef7352fb56bbae9f21e45faae1780e2f2975b.jpg)  
+Figure 7: Distribution of local label smoothness on PUBMED with various attack perturbation rates.
+
+• GCN-SVD (Entezari et al., 2020): GCN-SVD is also a pre-process method. It use SVD to decompose the adjacency matrix of a given perturbed graph and then obtain its low-rank approximation. The low-rank approximation is believed to be cleaner as graph adversarial attacks are observed to be high-rank in (Entezari et al., 2020).
+
+• Pro-GNN (Jin et al., 2020): Pro-GNN tries to learn a cleaner graph while training the node classification model at the same time. Specifically, it treats the adjacency as parameters, which is optimized during the training stage. Several different constraints are enforced to this learnable adjacency matrix, including: 1) the learned adjacency matrix should be close to the original adjacency matrix; 2) the learned adjacency matrix should be low-rank; and 3) the learned adjacency matrix should ensure feature smoothness. Pro-GNN-fs is a variant of Pro-GNN where the third constraint, i.e. feature smoothness, is not enforced.
+
+# C.5 INVESTIGATION ON NUMBER OF GRADIENT DESCENT STEPS IN ADA-UGNN
+
+In this section, we conducted experiments to check how the performance of ADA-UGNN is affected by $K$ . For each $K$ , we run the experiments on standard splits of CORA, CITESEER and PUBMED with 30 random seeds (i.e., the same setting as in Section 6.) The average performance is reported. As shown in Figure 8, the performance increases quickly as $K$ gets larger when $K$ is relatively small. After $K$ becomes large, the performance either slowly grows or slightly fluctuates as $K$ further increases.
+
+![](images/22d72b48cb14c504ec251dfc0d98b254d54f131bf76e747a5b1ae58336b19418.jpg)  
+Figure 8: ADA-UGNN performance (test accuracy) under different numbers of gradient steps $( K )$ .

parse/train/Syx9ET4YPB/Syx9ET4YPB.md

@@ -0,0 +1,333 @@
+# DO IMAGE CLASSIFIERS GENERALIZE ACROSS TIME?
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We study the robustness of image classifiers to temporal perturbations derived from videos. As part of this study, we construct ImageNet-Vid-Robust and YTBB-Robust, containing a total 57,897 images grouped into 3,139 sets of perceptually similar images. Our datasets were derived from ImageNet-Vid and Youtube-BB respectively and thoroughly re-annotated by human experts for image similarity. We evaluate a diverse array of classifiers pre-trained on ImageNet and show a median classification accuracy drop of 16 and 10 percent on our two datasets. Additionally, we evaluate three detection models and show that natural perturbations induce both classification as well as localization errors, leading to a median drop in detection mAP of 14 points. Our analysis demonstrates that perturbations occurring naturally in videos pose a substantial and realistic challenge to deploying convolutional neural networks in environments that require both reliable and low-latency predictions.
+
+# 1 INTRODUCTION
+
+Convolutional neural networks (CNNs) still exhibit many troubling failure modes. At one extreme, $\ell _ { p }$ -adversarial examples cause large drops in accuracy for state-of-the-art models while relying only on visually imperceptible changes to the input image (Goodfellow et al., 2014; Biggio and Roli, 2018). However, this failure mode usually does not pose a problem outside a fully adversarial context because carefully crafted $\ell _ { p }$ -perturbations are unlikely to occur naturally in the real world.
+
+To study more realistic failure modes, researchers have investigated benign image perturbations such as rotations & translations, colorspace changes, and various image corruptions (Fawzi and Frossard, 2015; Engstrom et al., 2017; Fawzi and Frossard, 2015; Hendrycks and Dietterich, 2019). However, it is still unclear whether these perturbations reflect the robustness challenges arising in real data since the perturbations also rely on synthetic image modifications.
+
+Recent work has therefore turned to videos as a source of naturally occurring perturbations of images (Zheng et al., 2016; Azulay and Weiss, 2018; Gu et al., 2019). In contrast to other failure modes, the perturbed images are taken from existing image data without further modifications that make the task more difficult. As a result, robustness to such perturbations directly corresponds to performance improvements on real data.
+
+However, it is currently unclear to what extent such video perturbations pose a significant robustness challenge. Azulay and Weiss (2018) and Zheng et al. (2016) only provide anecdotal evidence from a small number of videos. Gu et al. (2019) go beyond individual videos and utilize a large video dataset (Real et al., 2017) in order to measure the effect of video perturbations more quantitatively. In their evaluation, the best image classifiers lose about $3 \%$ accuracy for video frames up to 0.3 seconds away. However, the authors did not employ humans to review the frames in their videos. Hence the accuracy drop could also be caused by significant changes in the video frames (e.g., due to fast camera or object motion). Since the $3 \%$ accuracy drop is small to begin with, it remains unclear whether video perturbations are a robustness challenge for current image classifiers.
+
+We address these issues by conducting a thorough evaluation of robustness to natural perturbations arising in videos. As a cornerstone of our investigation, we introduce two test sets for evaluating model robustness: ImageNet-Vid-Robust and YTBB-Robust, carefully curated from the ImageNet-Vid and Youtube-BB datasets, respectively (Russakovsky et al., 2015; Real et al., 2017). All images in the two datasets were screened by a set of expert labelers to ensure high annotation quality and minimize selection biases that arise when filtering a dataset with CNNs. To the best of our knowledge these are the first datasets of their kind, containing tens of thousands of images that are human reviewed and grouped into thousands of perceptually similar sets. In total, our datasets contain 3,139 sets of temporally adjacent and visually similar images (57,897 images total).
+
+We then utilize these datasets to measure the accuracy of current CNNs to small, naturally occurring perturbations. Our testbed contains over 45 different models, varying both architecture and training methodology (adversarial training, data augmentation, etc.). To better understand the drop in accuracy due to natural perturbations, we also introduce a robustness metric that is more stringent than those employed in prior work. Under this metric, we find that natural perturbations from ImageNet-Vid-Robust and YTBB-Robust induce a median accuracy drop of $16 \%$ and $10 \%$ respectively for classification tasks and a median 14 point drop in mAP for detection tasks.1 Even for the best-performing classification models, we observe an accuracy drop of $14 \%$ for ImageNet-Vid-Robust and $8 \%$ for YTBB-Robust.
+
+Our results show that robustness to natural perturbations in videos is indeed a significant challenge for current CNNs. As these models are increasingly deployed in safety-critical environments that require both high accuracy and low latency (e.g., autonomous vehicles), ensuring reliable predictions on every frame of a video is an important direction for future work.
+
+![](images/3f6b30513a9f6483b745608a87d39877b703a1ece944de817966f2872e542011.jpg)  
+Figure 1: Three examples of natural perturbations from nearby video frames and resulting classifier confidences from a ResNet-152 model fine-tuned on ImageNet-Vid. While the images appear almost identical to the human eye, the classifier confidence changes substantially.
+
+# 2 CONSTRUCTING A TEST SET FOR ROBUSTNESS
+
+ImageNet-Vid-Robust and YTBB-Robust are sourced from videos in the ImageNet-Vid and Youtube-BB datasets (Russakovsky et al., 2015; Real et al., 2017). All object classes in ImageNet-Vid and Youtube-BB are from the WordNet hierarchy (Miller, 1995) and direct ancestors of ILSVRC-2012 classes. Using the WordNet hierarchy, we construct a canonical mapping from ILSVRC-2012 classes to ImageNet-Vid and Youtube-BB classes, which allows us to evaluate off-the-shelf ILSVRC-2012 models on ImageNet-Vid-Robust and YTBB-Robust. We provide more background on the source datsets in Appendix A.
+
+2.1 CONSTRUCTING IM A G ENE T-VI D-RO B U S T AND YTBB-RO B U S T
+
+Next, we describe how we extracted sets of naturally perturbed frames from ImageNet-Vid and Youtube-BB to create ImageNet-Vid-Robust and YTBB-Robust. A straightforward approach would be to select a set of anchor frames and use temporally adjacent frames in the video with the assumption that such frames contain only small perturbations from the anchor. However, as Fig. 2 illustrates, this assumption is frequently violated, especially due to fast camera or object motion.
+
+Instead, we first collect preliminary datasets of natural perturbations following the same approach, and then manually review each of the frame sets. For each video, we randomly sample an anchor frame and take $k = 1 0$ frames before and after the anchor frame as candidate perturbation images.2 This results in two datasets containing one anchor frame each from 3,139 videos, with approximately 20 candidate perturbation per anchor frame.3
+
+![](images/d9c52de0f9f2b2238ab572f72a307040e50e22ea95af85e046369fbc6ff7b8c5.jpg)  
+Figure 2: Temporally adjacent frames may not be visually similar. We show three randomly sampled frame pairs where the nearby frame was marked as “dissimilar” to the anchor frame during human review and then discarded from our dataset.
+
+Table 1: Statistics of ImageNet-Vid-Robust and YTBB-Robust. For YTBB-Robust, we updated the labels from for $41 \%$ (834) of the accepted anchors due to labeling errors in Youtube-BB.   
+
+<table><tr><td></td><td></td><td>ImageNet-Vid-Robust</td><td>YTBB-Robust</td></tr><tr><td rowspan="3">Anchor frames</td><td>Reviewed</td><td>1,314</td><td>2,467</td></tr><tr><td>Accepted</td><td>1,109 (84%)</td><td>2,030 (82%)</td></tr><tr><td>Labels updated</td><td>1</td><td>834 (41%)</td></tr><tr><td rowspan="2">Frame pairs</td><td>Reviewed</td><td>26,029</td><td>45,631</td></tr><tr><td>Accepted</td><td>21,070 (80.9%)</td><td>36,827 (80.7%)</td></tr></table>
+
+Next, we curate the dataset with the help of four expert human annotators. The goal of the curation step is to ensure that each anchor frame and its nearby frames are correctly labeled with the same ground truth class, and that the anchor frame and the nearby frames are visually similar.
+
+Denser labels for Youtube-BB. As Youtube-BB contains only a single category label per frame at 1 frame per second, annotators first viewed each anchor frame individually and marked any missing labels. In total, annotators corrected the labels for 834 frames, adding an average of 0.5 labels per anchor frame. These labels are then propagated to nearby, unlabeled frames at the native frame rate and verified in the next step. ImageNet-Vid densely labels all classes per frame, so we skip this step.
+
+Frame pairs review. Next, for each pair of anchor and candidate perturbation frames, a human annotates (i) whether the pair is correctly labeled in the dataset, and (ii) whether the pair is similar. We took several steps to mitigate the subjectivity of this task and ensure high annotation quality. First, we trained reviewers to mark frames as dissimilar if the scene undergoes any of the following transformations: significant motion, significant background change, or significant blur change. We asked reviewers to mark each dissimilar frame with one of these transformations, or “other”, and to mark a pair of images as dissimilar if a distinctive feature of the object is only visible in one of the two frames (such as the face of a dog). If an annotator was unsure about the correct label, she could mark the pair as “unsure”. Second, we present only a single pair of frames at a time to reviewers because presenting videos or groups of frames could cause them to miss large changes due to the phenomenon of change blindness (Pashler, 1988).
+
+Verification. In the previous stage, all annotators were given identical labeling instructions and individually reviewed a total of 71,660 images pairs. To increase consistency in annotation, annotators jointly reviewed all frames marked as dissimilar, incorrectly labeled, or “unsure”. A frame was only considered similar to its anchor if a strict majority of the annotators marked the pair as such.
+
+After the reviewing was complete, we discarded all anchor frames and candidate perturbations that annotators marked as dissimilar or incorrectly labeled. The final datasets contain a combined total of 3,139 anchor frames with a median of 20 similar frames each.
+
+# 2.2 THE P M-K EVALUATION METRIC
+
+Given the datasets introduced above, we propose a metric to measure a model’s robustness to natural perturbations. In particular, let $A = \{ a _ { 1 } , . . . , a _ { n } \}$ be the set of valid anchor frames in our dataset. Let $Y = \{ y _ { 1 } , . . . , y _ { n } \}$ be the set of labels for $A$ . We let $\textstyle { \mathcal { N } } _ { k } ( a _ { i } )$ be the set of frames marked as similar to anchor frame $a _ { i }$ . In our setting, $\mathcal { N } _ { k }$ is a subset of the $2 k$ temporally adjacent frames (plus/minus $\mathbf { k }$ frames from the anchor).
+
+Classification. Classification accuracy is defined as $\begin{array} { r } { \mathrm { a c c } _ { \mathrm { o r i g } } = 1 - \frac { 1 } { N } \sum _ { i = 0 } ^ { N } \mathcal { L } _ { 0 / 1 } ( f ( a _ { i } ) , y _ { i } ) } \end{array}$ , where $\mathcal { L } _ { 0 / 1 }$ is the standard 0-1 loss function. We define the $\mathrm { p m - k }$ analog of accuracy as
+
+$$
+\mathrm { a c c } _ { \mathrm { p m k } } = 1 - \frac { 1 } { N } \sum _ { i = 0 } ^ { N } \operatorname* { m a x } _ { b \in \mathcal { N } _ { k } ( a _ { i } ) } \mathcal { L } _ { 0 / 1 } ( f ( b ) , y _ { i } ) ,
+$$
+
+which corresponds to picking the worst frame from each set $\textstyle { \mathcal { N } } _ { k } ( a _ { i } )$ before computing accuracy.
+
+Detection. The standard metric for detection is mean average precision (mAP) of the predictions at a fixed intersection-over-union (IoU) threshold Lin et al. (2014). We define the $\mathrm { p m - k }$ metric analogous to that for classification: We replace each anchor frame with the nearest frame that minimizes the average precision (AP, averaged over recall thresholds) of the predictions, and compute $\mathrm { p m - k }$ as the mAP on these worst-case neighboring frames.
+
+# 3 MAIN RESULTS
+
+![](images/ce35b09ba50d55d64192d79ef52cb386fa1ca0e6d3e8f2da696a1913a871875d.jpg)  
+Figure 3: Model accuracy on original vs. perturbed images. Each data point corresponds to one model in our testbed (shown with $9 5 \%$ Clopper-Pearson confidence intervals). Each perturbed frame was taken from a ten frame neighborhood of the original frame (approximately 0.3 seconds). All frames were reviewed by humans to confirm visual similarity to the original frames.
+
+We evaluate a testbed of 45 classification and three detection models on ImageNet-Vid-Robust and YTBB-Robust. We first discuss the various types of classification models evaluated with the $\mathrm { p m - k }$ classification metric. Second, we evaluate the performance of detection models on ImageNet-Vid-Robust using use the bounding box annotations inherited from ImageNet-Vid using a variant of $\mathrm { p m - k }$ for detection. We then analyze the errors made on the detection adversarial examples to isolate the effects of localization errors vs. classification errors.
+
+# 3.1 CLASSIFICATION
+
+The classification robustness metric is $\mathrm { a c c } _ { \mathrm { p m k } }$ defined in Equation (1). For frames with multiple labels, we count a prediction as correct if the model predicts any of the correct classes for a frame. In Figure 3, we plot the benign accuracy, $\operatorname { a c c } _ { \mathrm { o r i g } }$ , versus the robust accuracy, $\mathrm { a c c } _ { \mathrm { p m k } }$ , for all classification models in our test bed and find that the relationship between $\operatorname { a c c } _ { \mathrm { o r i g } }$ and $\mathrm { a c c } _ { \mathrm { p m k } }$ is approximately linear. This relationship indicates that improvements in the benign accuracy do result in improvements in the worst-case accuracy, but do not suffice to resolve the accuracy drop due to natural perturbations.
+
+Our test bed consists of five model types with increasing levels of supervision. We present results for representative models from each model type in Table 2 and defer the full classification results table to Appendix B.2.
+
+Table 2: Accuracies of five different model types and the best performing model. The model architecture is ResNet-50 unless noted otherwise. ‘FT’ is ‘fine-tuning.’ See Section 3.1 for details.   
+
+<table><tr><td rowspan=1 colspan=3>Model Type                                  Accuracy          Accuracy        △PerturbedOriginal</td></tr><tr><td rowspan=1 colspan=3>ImageNet-Vid-Robust</td></tr><tr><td rowspan=1 colspan=3>Trained on ILSVRC                     67.5 [64.7, 70.3]  52.5 [49.5, 55.5]  15.0</td></tr><tr><td rowspan=1 colspan=3> + Noise Augmentation                  68.8 [66.0, 71.5]  53.2 [50.2, 56.2]  15.6</td></tr><tr><td rowspan=1 colspan=3>+lrobustness (ResNext-101)        54.3 [51.3, 57.2]  40.8 [39.0, 43.7]  12.4</td></tr><tr><td rowspan=1 colspan=3> + FT on ImageNet- Vid                  80.8 [78.3, 83.1]  65.7 [62.9, 68.5]  15.1</td></tr><tr><td rowspan=1 colspan=1>+ FT on ImageNet-Vid (ResNet-152)  84.8 [82.5, 86.8]</td><td rowspan=1 colspan=2>70.2 [67.4, 72.8]  14.6</td></tr><tr><td rowspan=1 colspan=3> + FT on ImageNet-Vid-Det             77.6 [75.1, 80.0]  65.4 [62.5, 68.1]  12.3</td></tr><tr><td rowspan=1 colspan=3>YTBB-Robust</td></tr><tr><td rowspan=1 colspan=1>Trained on ILSVRC                     57.0 [54.9, 59.2]</td><td rowspan=1 colspan=2>43.8 [41.7, 46.0]  13.2</td></tr><tr><td rowspan=1 colspan=1>+Noise Augmentation                  62.3 [60.2, 64.4]</td><td rowspan=1 colspan=1>45.7 [43.5, 47.9]</td><td rowspan=1 colspan=1>16.6</td></tr><tr><td rowspan=1 colspan=1> + l robustness (ResNext-101)        53.6 [51.4, 55.8]</td><td rowspan=1 colspan=1>43.2 [41.0, 45.3]</td><td rowspan=1 colspan=1>10.4</td></tr><tr><td rowspan=1 colspan=1>+ FT on Youtube-BB                    91.4 [90.1, 92.6]</td><td rowspan=1 colspan=1>82.0 [80.3, 83.7]</td><td rowspan=1 colspan=1>9.4</td></tr><tr><td rowspan=1 colspan=1> + FT on Youtube-BB (ResNet-152)    92.9 [91.6, 93.9]</td><td rowspan=1 colspan=1>84.7 [83.0, 86.2]</td><td rowspan=1 colspan=1>8.2</td></tr></table>
+
+ILSVRC Trained The WordNet hierarchy enables us to repurpose models trained for the 1,000 class ILSVRC dataset on ImageNet-Vid-Robust and YTBB-Robust (see Appendix A.1). We evaluate a wide array of ILSVRC-2012 models (available from Cadene) against our natural perturbations. Since these datasets present a substantial distribution shift from the original ILSVRC2012 validation, we expect the benign accuracy $\operatorname { a c c } _ { \mathrm { o r i g } }$ to be lower than the comparable accuracy on the ILSVRC-2012 validation set. However, our main interest here is in the difference between the original and perturbed accuracies $\operatorname { a c c } _ { \mathrm { o r i g } } - \operatorname { a c c } _ { \mathrm { p m k } }$ . A small drop in accuracy would indicate that the model is robust to small changes that occur naturally in videos. Instead, we find significant drops of $1 5 . 0 \%$ and $1 3 . 2 \%$ in accuracy on our two datasets, indicating sensitivity to such changes.
+
+Noise augmentation One hypothesis for the accuracy drop from original to perturbed accuracy is that subtle artifacts and corruptions introduced by video compression schemes could degrade performance when evaluating on these corrupted frames. The worst-case nature of the $\mathrm { p m - k }$ metric could then be focusing on these corrupted frames. One model for these corruptions are the perturbations introduced in Hendrycks and Dietterich (2019). To test this hypothesis, we evaluate models augmented with a subset of the perturbations (exactly one of: Gaussian noise, Gaussian blur, shot noise, contrast change, impulse noise, or JPEG compression). We found that these augmentation schemes did not improve robustness against our perturbations substantially, and still result in accuracy drop of $1 5 . 6 \%$ and $1 6 . 6 \%$ on the two datasets.
+
+$\ell _ { \infty }$ robustness. We evaluate the model from Xie et al. (2018), which currently performs best against $\ell _ { \infty }$ attacks on ImageNet. We find that this model has a smaller accuracy drop than the two aforementioned model types on both datasets. However, we note that the robust model achieves significantly lower original and perturbed accuracy than either of the two model types above, and the robustness gain is modest $3 \%$ compared to models of similar benign accuracy).
+
+Fine-tuning on video frames. To adapt to the new class vocabulary and the video domain, we fine-tune several network architectures on the ImageNet-Vid and Youtube-BB training sets. For Youtube-BB, we train on the anchor frames used for training in Gu et al. (2019), and for ImageNet-Vid we use all frames in the training set. We provide hyperparameters for all models in Appendix K.
+
+The resulting models significantly improve in accuracy over their ILSVRC pre-trained counterparts (e.g., $13 \%$ on ImageNet-Vid-Robust and $34 \%$ on YTBB-Robust for ResNet-50). This improvement in accuracy results in a modest improvement in the accuracy drop for YTBB-Robust, but a finetuned ResNet-50 still suffers from a significant $9 . 4 \%$ drop. On ImageNet-Vid-Robust, there is almost no change in the accuracy drop from $1 5 . 0 \%$ to $1 5 . 1 \%$ .
+
+Fine-tuning for detection on video frames. We further analyze whether additional supervision in the form of bounding box annotations improves robustness. To this end, we train the Faster R-CNN detection model Ren et al. (2015) with a ResNet-50 backbone on ImageNet-Vid. Following standard practice, the detection backbone is pre-trained on ILSVRC-2012. To evaluate this detector for classification, we assign the class with the most confident bounding box as label to the image. We find that this transformation reduces accuracy compared to the model trained for classification $( 7 7 . 6 \%$ vs. $8 0 . 8 \%$ ). While there is a slight reduction in the accuracy drop caused by natural perturbations, the reduction is well within the error bars for this test set.
+
+# 3.2 DETECTION
+
+We further study the impact of natural perturbations on object detection. Specifically, we report results for two related tasks: object localization and detection. Object detection is the standard computer vision task of correctly classifying an object and finding the coordinates of a tight bounding box containing the object. “Object localization”, meanwhile, refers to only the subtask of finding the bounding box, without attempting to correctly classify the object.
+
+We present our results on ImageNet-Vid-Robust, which contains dense bounding box labels unlike Youtube-BB, which only labels boxes at 1 frame per second. We use the popular Faster R-CNN Ren et al. (2015) and R-FCN Dai et al. (2016); Xiao and Jae Lee (2018) architectures for object detection and localization and report results in Table 3. For the R-FCN architecture, we use the model from Xiao and Jae Lee $( 2 0 1 8 ) ^ { 4 }$ . We first note the significant drop in mAP of 12 – 15 points for object detection due to perturbed frames for both the Faster R-CNN and R-FCN architectures. Next, we show that localization is indeed easier than detection, as the mAP is higher for localization than for detection (e.g., 76.6 vs 62.8 for Faster R-CNN with a ResNet-50 backbone). Perhaps surprisingly, however, switching to the localization task does not improve the drop between original and perturbed frames, indicating that natural perturbations induce both classification and localization errors. We show examples of detection failures in Figure 4.
+
+![](images/66cd8c2b8564417377f00f08cfec935c33d0a2cce3d3f68b46ab2790725206ef.jpg)  
+Figure 4: Naturally perturbed examples for detection. Red boxes indicate false positives; green boxes indicate true positives; white boxes are ground truth. Classification errors are common failures, such as the fox on the left, which is classified correctly in the anchor frame, and misclassified as a sheep in a nearby frame. However, detection models also have localization errors, where the object of interest is not correctly localized in addition to being misclassified, such as the airplane (middle) and the motorcycle (right). All visualizations show predictions with confidence greater than 0.5.
+
+# 3.3 IMPACT OF DATASET REVIEW
+
+We analyze the impact of our human review, described in Section 2.1, on the classifiers in our test bed. First, we compare the original and perturbed accuracies of a representative classifier (ResNet152 finetuned) with and without review in Table 4. Our review improves the original accuracy by $3- 4 \%$ by throwing away mislabeled or blurry anchor frames, and improves perturbed accuracy by $5- 6 \%$ by discarding pairs of dissimilar frames. Our review reduces the accuracy drop by $1 . 8 \%$ on
+
+Table 3: Detection and localization mAP for two Faster R-CNN backbones. Both detection and localization suffer from significant drops in mAP due to the perturbations. (\*Model trained on ILSVRC Det and VID 2015 datasets, and evaluated on the 2015 subset of ILSVRC-VID 2017.)   
+
+<table><tr><td>Task</td><td>Model</td><td>mAP Original</td><td>mAP Perturbed</td><td>mAP △</td></tr><tr><td rowspan="3">Detection</td><td>FRCNN,ResNet5</td><td>62.8</td><td>48.8</td><td>14.0</td></tr><tr><td>FRCNN,ResNet 101</td><td>63.1</td><td>50.6</td><td>12.5</td></tr><tr><td> R-FCN, ResNet 101 Xiao and Jae Lee (2018)*</td><td>79.4*</td><td>63.7*</td><td>15.7*</td></tr><tr><td rowspan="3">Localization</td><td>FRCNN,ResNet50</td><td>76.6</td><td>64.2</td><td>12.4</td></tr><tr><td>FRCNN, ResNet 101</td><td>77.8</td><td>66.3</td><td>11.5</td></tr><tr><td>R-FCN, ResNet 101*</td><td>80.9*</td><td>70.3*</td><td>10.6*</td></tr></table>
+
+ImageNet-Vid-Robust and $1 . 1 \%$ on YTBB-Robust, but still results in large accuracy drops. These results indicate that the changes in model predictions are indeed due to a lack of robustness, rather than due to significant differences between adjacent frames.
+
+To further analyze the impact of our review on model errors, we plot how frequently each offset distance from the anchor frame results in a model error across all model types in Figure 5. For both datasets, larger offsets (indicating pairs of frames further apart in time) lead to more frequent model errors. Our review reduces the fraction of errors across offsets, and especially for large offsets, which are more likely to display large changes from the anchor frame.
+
+![](images/4b62cf4ea50e313e218a252c96d0090fbe0855c3e30a90a9d4f5afba62738b13.jpg)  
+Figure 5: We plot the fraction of times each offset caused an error, across all evaluated models, for frames with and without review. Frames further away more frequently cause classifiers to misfire. Our review process reduces the number of errors, especially for frames further in time, by removing dissimilar frames.
+
+Table 4: Impact of human review on original and perturbed accuracies for ImageNet-Vid-Robust and YTBB-Robust, using a ResNet-152 fine-tuned on ImageNet-Vid and Youtube-BB, respectively.
+
+<table><tr><td></td><td colspan="4">Accuracy</td></tr><tr><td></td><td>Reviewed</td><td>Original</td><td>Perturbed</td><td>Drop</td></tr><tr><td rowspan="2">ImageNet-Vid-Robust</td><td></td><td>80.3</td><td>64.1</td><td>16.2</td></tr><tr><td>X</td><td>84.8</td><td>70.2</td><td>14.4</td></tr><tr><td rowspan="2">YTBB-Robust</td><td></td><td>88.1</td><td>78.1</td><td>10.0</td></tr><tr><td>X</td><td>92.9</td><td>84.7</td><td>8.9</td></tr></table>
+
+# 4 RELATED WORK
+
+Adversarial examples. While various forms of adversarial examples have been studied, the majority of research focuses on $\ell _ { p }$ robustness Goodfellow et al. (2014); Biggio and Roli (2018). However, it is unclear whether adversarial examples pose a problem for classifier robustness outside of a truly worst case context. It is an open question whether perfect robustness against a $\ell _ { p }$ adversary will induce robustness to realistic image distortions such as those studied in this paper. Recent work has proposed more realistic image modifications such as small rotations $\&$ translations Engstrom et al.
+
+(2017); Azulay and Weiss (2018); Fawzi and Frossard (2015); Kanbak et al. (2017), hue and color changes Hosseini and Poovendran (2018), image stylization Geirhos et al. (2018a) and synthetic image corruptions such as Gaussian blur and JPEG compression Hendrycks and Dietterich (2019); Geirhos et al. (2018b). Even though the above examples are more realistic than the $\ell _ { p }$ model, they still synthetically modify the input images to generate perturbed versions. In contrast, our work performs no synthetic modification and instead uses images that naturally occur in videos.
+
+Utilizing videos to study robustness. In work concurrent to ours, Gu et al. (2019) exploit the temporal structure in videos to study robustness. However, their experiments suggest a substantially smaller drop in classification accuracy. The primary reason for this is a less stringent metric used in Gu et al. (2019). By contrast, our “pm-k” metric is inspired by the “worst-of-k” metric used in prior work Engstrom et al. (2017), highlighting the sensitivity of models to natural perturbations. In Appendix E we study the differences between the two metrics in more detail. Furthermore, the lack of human review and the high label error-rate we discovered in Youtube-BB(Table 1) presents a troubling confounding factor that we resolve in our work.
+
+Distribution shift. Small, benign changes in the test distribution are often referred to as distribution shift. Recht et al. (2019) explore this phenomenon by constructing new test sets for CIFAR-10 and ImageNet and observe performance drops for a large suite of models on the newly constructed test sets. Similar to our Figure 3, the relationship between original and new test set accuracy is also approximately linear. However, the images in their test set bear little visual similarity to images in the original test set, while all of our failure cases in ImageNet-Vid-Robust and YTBB-Robust are on perceptually similar images. In a similar vein of study, Torralba et al. (2011) studies distribution shift across different computer vision data sets such as Caltech-101, PASCAL, and ImageNet.
+
+Computer vision. A common issue when applying image based models to videos is flickering, where object detectors spuriously produce false-positives or false-negatives in isolated frames or groups of frames. Jin et al. (2018) explicitly identify such failures and use a technique reminiscent of adversarially robust training to improve image-based models. A similar line of work focuses on improving object detection in videos as objects become occluded or move quickly Kang et al. (2017); Feichtenhofer et al. (2017); Zhu et al. (2017); Xiao and Jae Lee (2018). The focus in this line of work has generally been on improving object detection when objects transform in a way that makes recognition difficult from a single frame, such as fast motion or occlusion. In this work, we document a broader set of failure cases for image-based classifiers and detectors and show that failures occur when the neighboring frames are imperceptibly different.
+
+# 5 CONCLUSION
+
+Our study quantifies the sensitivity of image classifiers to naturally occuring temporal perturbations. We show that these perturbations can cause significant drops in accuracy for a wide range of models for both classification and detection. Our work on analyzing this failure mode opens multiple avenues for future research:
+
+Building more robust models. Our ImageNet-Vid-Robust and YTBB-Robust datasets provide a standard measure for robustness that can be applied to any classification or detection model. In Table 2, we evaluated several commonly used models and found that all of them suffer from substantial accuracy drops due to natural perturbations. In particular, we found that model improvements with respect to artificial perturbations (such as image corruptions or $\ell _ { \infty }$ adversaries) induce at best modest improvements in robustness. We hope that our standardized datasets and evaluation metric will enable future work to quantify improvements in natural robustness directly.
+
+Further natural perturbations. Videos provide a straightforward method for collecting natural perturbations of images, admitting the study of realistic forms of robustness for machine learning methods. Other methods for generating these natural perturbations are likely to provide additional insights into model robustness. As an example, photo sharing websites contain a large number of near-duplicate images: pairs of images of the same scene captured at different times, viewpoints, or from a different camera Recht et al. (2019). More generally, devising similar, domain-specific strategies to collect, verify, and measure robustness to natural perturbations in domains such as natural language processing or speech recognition is a promising direction for future work.
+
+# REFERENCES
+
+Aharon Azulay and Yair Weiss. Why do deep convolutional networks generalize so poorly to small image transformations? arXiv preprint arXiv:1805.12177, 2018.
+
+Luca Bertinetto, Jack Valmadre, Joao F Henriques, Andrea Vedaldi, and Philip HS Torr. Fullyconvolutional siamese networks for object tracking. In European conference on computer vision, pages 850–865. Springer, 2016.
+
+Battista Biggio and Fabio Roli. Wild patterns: Ten years after the rise of adversarial machine learning. Pattern Recognition, 2018. https://arxiv.org/abs/1712.03141.
+
+Remi Cadene. Pretrained models for pytorch. https://github.com/Cadene/pretrain ed-models.pytorch. Accessed: 2019-05-20.
+
+Jifeng Dai, Yi Li, Kaiming He, and Jian Sun. R-fcn: Object detection via region-based fully convolutional networks. In Advances in neural information processing systems, pages 379–387, 2016.
+
+Logan Engstrom, Brandon Tran, Dimitris Tsipras, Ludwig Schmidt, and Aleksander Madry. A rotation and a translation suffice: Fooling cnns with simple transformations. arXiv preprint arXiv:1712.02779, 2017.
+
+Alhussein Fawzi and Pascal Frossard. Manitest: Are classifiers really invariant? In British Machine Vision Conference (BMVC), 2015.
+
+Christoph Feichtenhofer, Axel Pinz, and Andrew Zisserman. Detect to track and track to detect. In Proceedings of the IEEE International Conference on Computer Vision, pages 3038–3046, 2017.
+
+Robert Geirhos, Patricia Rubisch, Claudio Michaelis, Matthias Bethge, Felix A Wichmann, and Wieland Brendel. Imagenet-trained cnns are biased towards texture; increasing shape bias improves accuracy and robustness. arXiv preprint arXiv:1811.12231, 2018a.
+
+Robert Geirhos, Carlos RM Temme, Jonas Rauber, Heiko H Schütt, Matthias Bethge, and Felix A Wichmann. Generalisation in humans and deep neural networks. In Advances in Neural Information Processing Systems, pages 7538–7550, 2018b.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Keren Gu, Brandon Yang, Jiquan Ngiam, Quoc Le, and Jonathan Shlens. Using videos to evaluate image model robustness. arXiv preprint arXiv:1904.10076, 2019.
+
+Wei Han, Pooya Khorrami, Tom Le Paine, Prajit Ramachandran, Mohammad Babaeizadeh, Honghui Shi, Jianan Li, Shuicheng Yan, and Thomas S Huang. Seq-nms for video object detection. arXiv preprint arXiv:1602.08465, 2016.
+
+Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. arXiv preprint arXiv:1903.12261, 2019.
+
+Hossein Hosseini and Radha Poovendran. Semantic adversarial examples. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pages 1614–1619, 2018.
+
+SouYoung Jin, Aruni RoyChowdhury, Huaizu Jiang, Ashish Singh, Aditya Prasad, Deep Chakraborty, and Erik Learned-Miller. Unsupervised hard example mining from videos for improved object detection. In ECCV, 2018.
+
+Can Kanbak, Seyed-Mohsen Moosavi-Dezfooli, and Pascal Frossard. Geometric robustness of deep networks: analysis and improvement. arXiv preprint arXiv:1711.09115, 2017.
+
+Kai Kang, Hongsheng Li, Tong Xiao, Wanli Ouyang, Junjie Yan, Xihui Liu, and Xiaogang Wang. Object detection in videos with tubelet proposal networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 727–735, 2017.
+
+Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. MS COCO detection evaluation. http://cocodataset.or g/#detection-eval. Accessed: 2019-05-16.
+
+Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In European conference on computer vision, pages 740–755. Springer, 2014.
+
+Francisco Massa and Ross Girshick. maskrcnn-benchmark: Fast, modular reference implementation of Instance Segmentation and Object Detection algorithms in PyTorch. https://github.c om/facebookresearch/maskrcnn-benchmark, 2018. Accessed: 2019-05-20.
+
+George A Miller. Wordnet: a lexical database for english. Communications of the ACM, 38(11): 39–41, 1995.
+
+Harold Pashler. Familiarity and visual change detection. Perception & psychophysics, 44(4):369–378, 1988.
+
+Esteban Real, Jonathon Shlens, Stefano Mazzocchi, Xin Pan, and Vincent Vanhoucke. Youtubeboundingboxes: A large high-precision human-annotated data set for object detection in video. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5296–5305, 2017.
+
+Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do imagenet classifiers generalize to imagenet? arXiv preprint arXiv:1902.10811, 2019.
+
+Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In Advances in neural information processing systems, pages 91–99, 2015.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li FeiFei. ImageNet Large Scale Visual Recognition Challenge. IJCV, 115(3):211–252, 2015. doi: 10.1007/s11263-015-0816-y.
+
+Antonio Torralba, Alexei A Efros, et al. Unbiased look at dataset bias. In CVPR, volume 1, page 7. Citeseer, 2011.
+
+Fanyi Xiao and Yong Jae Lee. Video object detection with an aligned spatial-temporal memory. In Proceedings of the European Conference on Computer Vision (ECCV), pages 485–501, 2018.
+
+Cihang Xie, Yuxin Wu, Laurens van der Maaten, Alan Yuille, and Kaiming He. Feature denoising for improving adversarial robustness. arXiv preprint arXiv:1812.03411, 2018.
+
+Stephan Zheng, Yang Song, Thomas Leung, and Ian Goodfellow. Improving the robustness of deep neural networks via stability training. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), Jun 2016. doi: 10.1109/cvpr.2016.485. URL http://dx.doi.org/10. 1109/cvpr.2016.485.
+
+Xizhou Zhu, Yujie Wang, Jifeng Dai, Lu Yuan, and Yichen Wei. Flow-guided feature aggregation for video object detection. In Proceedings of the IEEE International Conference on Computer Vision, pages 408–417, 2017.
+
+# A SOURCE DATASET OVERVIEW
+
+# A.1 IMAGENET-VID
+
+The 2015 ImageNet-Vid dataset is widely used for training video object detectors Han et al. (2016) as well as trackers Bertinetto et al. (2016). We chose to work with the 2017 ImageNet-Vid dataset because it is a superset of the 2015 dataset. In total, the 2017 ImageNet-Vid dataset consists of 1,181,113 training frames from 4,000 videos and 512,360 validation frames from 1,314 videos. The videos have frame rates ranging from 9 to 59 frames per second (fps), with a median fps of 29. The videos range from 0.44 to 96 seconds in duration with a median duration of 12 seconds. Each frame is annotated with labels indicating the presence or absence of 30 object classes and corresponding bounding boxes for any label present in the frame. The 30 classes are ancestors of 293 of the 1,000 ILSVRC-2012 classes.
+
+# A.2 YOUTUBE-BB
+
+The 2017 Youtube-BB is a a large scale dataset with 8,146,143 annotated training frames 253,569 unique videos and with 1,013,246 validation frames from 31,829 videos. The video segments are approximately 19 seconds long on average. Each frame is annotated with exactly one label indicating the presence of 22 object classes, all of which are ancestors of 229 out of the ILSVRC-2012 classes.
+
+# B FULL ORIGINAL VS PERTURBED ACCURACIES
+
+B.1 IM A G ENE T-VI D-RO B U S T
+
+<table><tr><td>Model</td><td>Accuracy Original</td><td>Accuracy Perturbed</td><td></td><td>△</td></tr><tr><td>resnet152_finetuned</td><td>84.8 [82.5, 86.8]</td><td></td><td>70.2 [67.4, 72.8]</td><td>14.6</td></tr><tr><td>resnet50_finetuned</td><td>80.8 [78.3, 83.1]</td><td></td><td>65.7 [62.9, 68.5]</td><td>15.1</td></tr><tr><td> vgg16bn_finetuned</td><td>78.0 [75.4, 80.4]</td><td></td><td>61.0 [58.1, 63.9]</td><td>17.0</td></tr><tr><td> nasnetalarge_imagenet_pretrained</td><td>77.6 [75.1, 80.1]</td><td></td><td>62.1 [59.2, 65.0]</td><td>15.5</td></tr><tr><td>resnet50_detection</td><td>77.6 [75.1, 80.1]</td><td></td><td>65.0 [62.1, 67.8]</td><td>12.6</td></tr><tr><td>inceptionresnetv2_imagenet_pretrained</td><td>75.7 [73.1, 78.2]</td><td></td><td>58.7 [55.7, 61.6]</td><td>17.0</td></tr><tr><td>dpn107_imagenet_pretrained</td><td>75.6 [72.9, 78.1]</td><td></td><td>59.1 [56.1, 62.0]</td><td>16.5</td></tr><tr><td>inceptionv4_imagenet_pretrained</td><td>75.3 [72.6, 77.8]</td><td></td><td>59.0 [56.0, 61.9]</td><td>16.3</td></tr><tr><td>dpn92_imagenet_pretrained</td><td>74.4 [71.7, 76.9]</td><td></td><td>56.8 [53.8, 59.7]</td><td>17.6</td></tr><tr><td>dpn131_imagenet_pretrained</td><td>74.0 [71.3, 76.6]</td><td></td><td>59.9 [56.9, 62.8]</td><td>14.1</td></tr><tr><td> dpn68b_imagenet_pretrained</td><td>73.7 [71.0, 76.2]</td><td></td><td>54.0 [51.0, 57.0]</td><td>19.7</td></tr><tr><td>resnext101_32x4d_imagenet_pretrained</td><td>73.3 [70.6, 75.9]</td><td></td><td>57.2 [54.2, 60.1]</td><td>16.1</td></tr><tr><td> resnext101_64x4d_imagenet_pretrained</td><td>72.9 [70.1, 75.5]</td><td></td><td>56.6 [53.7, 59.6]</td><td>16.3</td></tr><tr><td>resnet152_imagenet_pretrained</td><td>72.8 [70.0, 75.4]</td><td></td><td>57.0 [54.0, 59.9]</td><td>15.8</td></tr><tr><td> resnet1O1_imagenet_pretrained</td><td>71.5 [68.7, 74.1]</td><td></td><td>53.7 [50.8, 56.7]</td><td>17.8</td></tr><tr><td>fbresnet152_imagenet_pretrained</td><td>71.5 [68.7, 74.1]</td><td></td><td>54.5 [51.5, 57.4]</td><td>17.0</td></tr><tr><td>densenet161_imagenet_pretrained</td><td>71.4 [68.7, 74.1]</td><td></td><td>55.1 [52.1, 58.1]</td><td>16.3</td></tr><tr><td>densenet169_imagenet_pretrained</td><td>70.2 [67.5, 72.9]</td><td></td><td>53.1 [50.1, 56.1]</td><td>17.1</td></tr><tr><td> densenet2O1_imagenet_pretrained</td><td>70.2 [67.5, 72.9]</td><td></td><td>53.4 [50.4, 56.4]</td><td>16.8</td></tr><tr><td>dpn68_imagenet_pretrained</td><td>69.4 [66.6, 72.1]</td><td></td><td>53.3 [50.3, 56.3]</td><td>16.1</td></tr><tr><td> bninception_imagenet_pretrained</td><td>69.0 [66.2, 71.7]</td><td></td><td>49.0 [46.0, 51.9]</td><td>20.0</td></tr><tr><td>densenet121_imagenet_pretrained</td><td>69.0 [66.2, 71.7]</td><td></td><td>50.9 [47.9, 53.8]</td><td>18.1</td></tr><tr><td> nasnetamobile_imagenet_pretrained</td><td>68.8 [66.0, 71.5]</td><td></td><td>48.4 [45.4, 51.4]</td><td>20.4</td></tr><tr><td>resnet50_augment_ jpeg_compression</td><td>68.8 [66.0, 71.5]</td><td></td><td>53.2 [50.2, 56.2]</td><td>15.6</td></tr><tr><td> resnet34_imagenet_pretrained</td><td>68.0 [65.2, 70.7]</td><td></td><td>48.0 [45.0, 51.0]</td><td>20.0</td></tr><tr><td>resnet50_augment impulse_noise</td><td>67.7 [64.9, 70.5]</td><td></td><td>50.2 [47.2, 53.2]</td><td>17.5</td></tr><tr><td> resnet50_augment_gaussian_blur</td><td>67.7 [64.9, 70.5]</td><td></td><td>52.5 [49.5, 55.5]</td><td>15.2</td></tr><tr><td>resnet5O_imagenet_pretrained</td><td>67.5 [64.7, 70.3]</td><td></td><td>52.5 [49.5, 55.5]</td><td>15.0</td></tr><tr><td>resnet50_augment gaussian_noise</td><td>67.4 [64.5, 70.1]</td><td></td><td>50.6 [47.6, 53.6]</td><td>16.8</td></tr><tr><td>resnet50_augment shot_noise</td><td>66.5 [63.6, 69.2]</td><td></td><td>51.1 [48.1, 54.1]</td><td>15.4</td></tr><tr><td> vgg16_bn_imagenet_pretrained</td><td>66.4 [63.5, 69.1]</td><td></td><td>47.4 [44.5, 50.4]</td><td>19.0</td></tr><tr><td>resnet50_augment_ _defocus_blur</td><td>66.3 [63.4, 69.1]</td><td></td><td>47.6 [44.6, 50.6]</td><td>18.7</td></tr><tr><td> vgg19_bn_imagenet_pretrained</td><td>65.6 [62.7, 68.4]</td><td></td><td>46.6 [43.6, 49.6]</td><td>19.0</td></tr></table>
+
+Table 5: Classification model perturbed and original accuracies for all models in our test bed evaluated on the ImageNet-Vid-Robust dataset.   
+
+<table><tr><td>vgg19_imagenet_pretrained</td><td></td><td>63.2 [60.3, 66.1]</td><td></td><td>45.4 [42.4, 48.3]</td><td>17.8</td></tr><tr><td>resnet18_imagenet_pretrained</td><td></td><td>61.9 [59.0, 64.8]</td><td></td><td>41.5 [38.6, 44.4]</td><td>20.4</td></tr><tr><td>vgg13_bn_imagenet_pretrained</td><td></td><td>61.9 [59.0, 64.8]</td><td></td><td>43.3 [40.3, 46.3]</td><td>18.6</td></tr><tr><td>vgg16_imagenet_pretrained</td><td></td><td>61.4 [58.5, 64.3]</td><td></td><td>43.1 [40.2, 46.1]</td><td>18.3</td></tr><tr><td>vgg11_bn_imagenet_pretrained</td><td></td><td>60.9 [57.9, 63.8]</td><td></td><td>43.2 [40.3, 46.2]</td><td>17.7</td></tr><tr><td> vgg13_imagenet_pretrained</td><td></td><td>59.6 [56.6, 62.5]</td><td></td><td>41.1 [38.2, 44.1]</td><td>18.5</td></tr><tr><td>vgg11_imagenet_pretrained</td><td></td><td>57.3 [54.4, 60.3]</td><td></td><td>41.3 [38.4, 44.3]</td><td>16.0</td></tr><tr><td> alexnet_finetuned</td><td></td><td>57.3 [54.3, 60.2]</td><td></td><td>43.6 [40.7, 46.6]</td><td>13.7</td></tr><tr><td>ResNeXtDenoiseAll-101_robust_pgd</td><td></td><td>54.3 [51.3, 57.2]</td><td></td><td>40.8 [37.8, 43.7]</td><td>13.5</td></tr><tr><td> squeezenet1_1_imagenet_pretrained</td><td></td><td>49.8 [46.8, 52.8]</td><td></td><td>31.7 [28.9, 34.5]</td><td>18.1</td></tr><tr><td>alexnet_imagenet_pretrained</td><td></td><td>49.4 [46.4, 52.4]</td><td></td><td>32.0 [29.3, 34.8]</td><td>17.4</td></tr><tr><td>resnet50_augment contrast_change</td><td></td><td>38.3 [35.5, 41.3]</td><td></td><td>23.3 [20.8, 25.9]</td><td>15.0</td></tr></table>
+
+# B.2 YTBB-RO B U S T
+
+<table><tr><td>Model</td><td>Accuracy Original</td><td>Accuracy Perturbed</td><td></td><td>△</td></tr><tr><td>resnet152_finetuned</td><td></td><td>92.9 [91.2, 94.3]</td><td>84.7 [82.4, 86.8]</td><td>8.2</td></tr><tr><td>resnet50_finetuned</td><td>91.4 [89.6, 93.0]</td><td></td><td>82.0 [79.6, 84.2]</td><td>9.4</td></tr><tr><td> inceptionresnetv2_finetuned</td><td>91.3 [89.5, 92.9]</td><td></td><td>79.0 [76.4, 81.3]</td><td>12.3</td></tr><tr><td>vgg19_finetuned</td><td>90.5 [88.6, 92.2]</td><td></td><td>79.1 [76.5, 81.4]</td><td>11.4</td></tr><tr><td> vgg16_finetuned</td><td>89.1 [87.1, 90.8]</td><td></td><td>78.0 [75.4, 80.4]</td><td>11.1</td></tr><tr><td>inceptionv4_finetuned</td><td>88.5 [86.5, 90.3]</td><td></td><td>76.3 [73.6, 78.7]</td><td>12.2</td></tr><tr><td> resnet18_finetuned</td><td>88.0 [85.9, 89.8]</td><td></td><td>76.2 [73.6, 78.7]</td><td>11.8</td></tr><tr><td>alexnet_finetuned</td><td>80.6 [78.2, 82.9]</td><td></td><td>64.4 [61.5, 67.3]</td><td>16.2</td></tr><tr><td> pnasnet5large_imagenet_pretrained</td><td>65.2 [62.3, 68.0]</td><td></td><td>51.0 [48.0, 54.0]</td><td>14.2</td></tr><tr><td>nasnetalarge_imagenet_pretrained</td><td>64.9 [62.0, 67.7]</td><td></td><td>51.4 [48.4, 54.4]</td><td>13.5</td></tr><tr><td> inceptionresnetv2_imagenet_pretrained</td><td>64.5 [61.6, 67.4]</td><td></td><td> 50.4 [47.5, 53.4]</td><td>14.1</td></tr><tr><td>dpn98_imagenet_pretrained</td><td>64.1 [61.2, 66.9]</td><td></td><td>49.0 [46.0, 52.0]</td><td>15.1</td></tr><tr><td> dpn107_imagenet_pretrained</td><td>64.1 [61.2, 66.9]</td><td></td><td>50.1 [47.2, 53.1]</td><td>14.0</td></tr><tr><td>dpn131_imagenet_pretrained</td><td>64.0 [61.1, 66.8]</td><td></td><td>49.9 [46.9, 52.9]</td><td>14.1</td></tr><tr><td> inceptionv4_imagenet_pretrained</td><td>63.6 [60.7, 66.4]</td><td></td><td>48.8 [45.8, 51.8]</td><td>14.8</td></tr><tr><td>Xception_imagenet_pretrained</td><td>63.2 [60.2, 66.0]</td><td></td><td>47.6 [44.6, 50.6]</td><td>15.6</td></tr><tr><td> dpn92_imagenet_pretrained</td><td>62.3 [59.3, 65.1]</td><td></td><td>47.7 [44.8, 50.7]</td><td>14.6</td></tr><tr><td>resnet50_augment_jpeg_compressioon</td><td>62.3 [59.4, 65.2]</td><td></td><td>45.7 [42.8, 48.7]</td><td>16.6</td></tr><tr><td> polynet_imagenet_pretrained</td><td>61.4 [58.4, 64.3]</td><td></td><td>47.3 [44.4, 50.3]</td><td>14.1</td></tr><tr><td>nasnetamobile_imagenet_pretrained</td><td>61.4 [58.4, 64.3]</td><td></td><td>43.0 [40.1, 46.0]</td><td>18.4</td></tr><tr><td>resnet50_augment__shot_noise</td><td>61.3 [58.3, 64.2]</td><td></td><td>46.4 [43.4, 49.3]</td><td>14.9</td></tr><tr><td>dpn68_imagenet_pretrained</td><td>61.2 [58.3, 64.1]</td><td></td><td>44.2 [41.2, 47.2]</td><td>17.0</td></tr><tr><td> fbresnet152_imagenet_pretrained</td><td>61.1 [58.1, 64.0]</td><td></td><td>45.9 [42.9, 48.8]</td><td>15.2</td></tr><tr><td>resnet152_imagenet_pretrained</td><td>60.8 [57.8, 63.7]</td><td></td><td>46.5 [43.5, 49.5]</td><td>14.3</td></tr><tr><td> resnet101_imagenet_pretrained</td><td>60.8 [57.8, 63.7]</td><td></td><td>45.2 [42.2, 48.2]</td><td>15.6</td></tr><tr><td>senet154_imagenet_pretrained</td><td>60.7 [57.7, 63.6]</td><td></td><td>47.2 [44.3, 50.2]</td><td>13.5</td></tr><tr><td> resnet50_augment__impulse_noise</td><td>60.6 [57.7, 63.5]</td><td></td><td>45.5 [42.6, 48.5]</td><td>15.1</td></tr><tr><td> se_resnet101_imagenet_pretrained</td><td>60.5 [57.6, 63.4]</td><td></td><td>45.6 [42.6, 48.6]</td><td>14.9</td></tr><tr><td>bninception_imagenet_pretrained</td><td>60.4 [57.4, 63.3]</td><td></td><td>41.8 [38.9, 44.7]</td><td>18.6</td></tr><tr><td>densenetl61_imagenet_pretrained</td><td>60.2 [57.3, 63.1]</td><td></td><td>46.4 [43.4, 49.4]</td><td>13.8</td></tr><tr><td> resnet50_augment_gaussian_noise</td><td>60.2 [57.3, 63.1]</td><td></td><td>45.7 [42.8, 48.7]</td><td>14.5</td></tr><tr><td>se_resnext50_32x4d_imagenet_pretrained</td><td>59.9 [56.9, 62.8]</td><td></td><td>45.7 [42.7, 48.6]</td><td>14.2</td></tr><tr><td> dpn68b_imagenet_pretrained</td><td>59.7 [56.7, 62.6]</td><td></td><td>45.9 [42.9, 48.8]</td><td>13.8</td></tr><tr><td>inceptionv3_imagenet_pretrained</td><td>59.6 [56.6, 62.5]</td><td></td><td>43.8 [40.8, 46.8]</td><td>15.8</td></tr><tr><td> densenet121_imagenet_pretrained</td><td>59.5 [56.5, 62.4]</td><td></td><td>43.1 [40.1, 46.0]</td><td>16.4</td></tr><tr><td>se_resnext101_32x4d_imagenet_pretrained</td><td>59.2 [56.3, 62.1]</td><td></td><td>45.2 [42.3, 48.2]</td><td>14.0</td></tr><tr><td> densenet2O1_imagenet_pretrained</td><td>59.2 [56.2, 62.1]</td><td></td><td>44.8 [41.8, 47.8]</td><td>14.4</td></tr><tr><td>densenet169_imagenet_pretrained</td><td>59.2 [56.2, 62.1]</td><td></td><td>44.6 [41.7, 47.6]</td><td>14.6</td></tr></table>
+
+Table 6: Classification model perturbed and original accuracies for all models in our test bed evaluated on the YTBB-robust dataset..   
+
+<table><tr><td> resnet50_augment__brightness_change</td><td></td><td>58.9 [56.0, 61.8]</td><td></td><td>42.6 [39.6, 45.5]</td><td>16.3</td></tr><tr><td>se_resnet50_imagenet_pretrained</td><td></td><td>58.8 [55.9, 61.7]</td><td></td><td>44.1 [41.1, 47.1]</td><td>14.7</td></tr><tr><td> se_resnet152_imagenet_pretrained</td><td></td><td>58.8 [55.9, 61.7]</td><td></td><td>44.8 [41.9, 47.8]</td><td>14.0</td></tr><tr><td>cafferesnetlO1_imagenet_pretrained</td><td></td><td>58.2 [55.2, 61.1]</td><td></td><td>44.3 [41.3, 47.3]</td><td>13.9</td></tr><tr><td> resnet50_augment__regular</td><td></td><td>58.0 [55.1, 61.0]</td><td></td><td>42.9 [39.9, 45.8]</td><td>15.1</td></tr><tr><td>resnet34_imagenet_pretrained</td><td></td><td>57.9 [55.0, 60.9]</td><td></td><td>42.8 [39.8, 45.7]</td><td>15.1</td></tr><tr><td> vgg19_imagenet_pretrained</td><td></td><td>57.5 [54.6, 60.5]</td><td></td><td>40.1 [37.2, 43.1]</td><td>17.4</td></tr><tr><td>resnet50_augment t_gaussian_blur</td><td></td><td>57.5 [54.5, 60.4]</td><td></td><td>41.8 [38.9, 44.7]</td><td>15.7</td></tr><tr><td> vgg16_bn_imagenet_pretrained</td><td></td><td>57.2 [54.2, 60.1]</td><td></td><td>39.6 [36.7, 42.6]</td><td>17.6</td></tr><tr><td>resnet5O_imagenet_pretrained</td><td></td><td>57.0 [54.1, 60.0]</td><td></td><td>43.8 [40.9, 46.8]</td><td>13.2</td></tr><tr><td>vgg19_bn_imagenet_pretrained</td><td></td><td>56.8 [53.9, 59.8]</td><td></td><td>40.6 [37.7, 43.5]</td><td>16.2</td></tr><tr><td>vgg16_imagenet_pretrained</td><td></td><td>55.4 [52.4, 58.4]</td><td></td><td>40.1 [37.2, 43.1]</td><td>15.3</td></tr><tr><td> vgg13_bn_imagenet_pretrained</td><td></td><td>54.8 [51.8, 57.7]</td><td></td><td>38.6 [35.7, 41.6]</td><td>16.2</td></tr><tr><td>vgg11_bn_imagenet_pretrained</td><td></td><td>54.8 [51.8, 57.7]</td><td></td><td>38.8 [35.9, 41.8]</td><td>16.0</td></tr><tr><td> vgg11_imagenet_pretrained</td><td></td><td>54.7 [51.7, 57.6]</td><td></td><td>38.4 [35.5, 41.3]</td><td>16.3</td></tr><tr><td>resnetl8_imagenet_pretrained</td><td></td><td>54.4 [51.4, 57.4]</td><td></td><td>38.1 [35.2, 41.0]</td><td>16.3</td></tr><tr><td> vgg13_imagenet_pretrained</td><td></td><td>54.2 [51.3, 57.2]</td><td></td><td>37.7 [34.9, 40.7]</td><td>16.5</td></tr><tr><td>ResNeXtDenoiseAll-101_robust_pgd</td><td></td><td>53.6 [50.7, 56.6]</td><td></td><td>43.2 [40.2, 46.1]</td><td>10.4</td></tr><tr><td> squeezenet1_O_imagenet_pretrained</td><td></td><td>51.1 [48.1, 54.1]</td><td></td><td>33.1 [30.3, 36.0]</td><td>18.0</td></tr><tr><td>squeezenetl_1_imagenet_pretrained</td><td></td><td>48.6 [45.6, 51.6]</td><td></td><td>31.3 [28.6, 34.2]</td><td>17.3</td></tr><tr><td>resnet50_augment__defocus_blur</td><td></td><td>48.4 [45.4, 51.4]</td><td></td><td>29.1 [26.4, 31.8]</td><td>19.3</td></tr><tr><td>alexnet_imagenet_pretrained</td><td></td><td>45.3 [42.4, 48.3]</td><td></td><td>30.5 [27.8, 33.3]</td><td>14.8</td></tr></table>
+
+# C MODEL INDEPENDENT DISTRIBUTION SHIFT
+
+Though the distribution shift we induced in our study were model dependent because we found the worst neighbor frame for each model, we could study the same problem but impose a static set of perturbed frames across all models. In Figure 6 we study this static set of perturbations across all models and see a substantial (but smaller) drop in accuracy for both models. The static set of perturbations were chosen by choosing the neighbor frame that the largest number of models classified incorrectly.
+
+![](images/f98513794c5a4b0f8364b14f6fc979d78acf7145cef44bd78021361128348e1b.jpg)  
+Figure 6: Model accuracy on original vs. perturbed images for a static set of perturbed frames across all models. The grey points and grey linear fit correspond to the perturbed accuracies of models evaluated on per model perturbations studied in Figure 3
+
+# D PER CLASS ANALYSIS
+
+We study the effect of our perturbations on the 30 classes in ImageNet-Vid-Robust and YTBB-Robust to determine whether the performance drop was concentrated in a few “hard” classes.
+
+![](images/6b8eca5801bdad58477c76ca5301b691cb302d1a0faade4664d14d0cc70e681e.jpg)  
+Figure 7: Per-class accuracy statistics for our best performing classification model (fine-tuned ResNet152) on ImageNet-Vid-Robust and YTBB-Robust. For Youtube-BB, note that ‘zebra’ is the least common label, present in only 24 anchor frames sampled by Gu et al. (2019), of which 4 are included in our dataset.
+
+Figure 7 shows the original and perturbed accuracies across classes for our best performing model (a fine-tuned ResNet-152). Although there are a few particularly difficult classes for perturbed accuracy (e.g., lion or monkey on ImageNet-Vid-Robust), the accuracy drop is spread across most classes. On ImageNet-Vid-Robust, this model saw a total drop of $1 4 . 4 \%$ between original and perturbed images and a median drop of $1 4 . 0 \%$ in per-class accuracy. On YTBB-Robust, the total drop was $8 . 9 \%$ and the median drop was $6 . 7 \%$ .
+
+# E PER-FRAME CONDITIONAL ROBUSTNESS METRIC INTRODUCED IN GU ET AL. (2019)
+
+![](images/f195e130e1ed7f7e17d4566723b10a4c294967b869b1c196598e6b4a3fdc0427.jpg)  
+Figure 8: Conditional robustness metric from Gu et al. (2019) on perturbed frames as a function of perturbation distance on ImageNet-Vid-Robust and YTBB-Robust. Model accuracies from five different model types and the best performing model are shown. The model architecture is ResNet-50 unless otherwise mentioned.
+
+In concurrent work, the authors of Gu et al. (2019) considered a different metric of robustness. In this section, we compute this metric on all models in our test bed to compare our findings to $\mathrm { G u }$ et al. (2019). There are two main differences between PM- $\mathbf { \nabla } \cdot \mathbf { k }$ and the robustness metric in Gu et al. (2019).
+
+1. For two visually similar “neighbor” frames $I _ { 0 }$ and $I _ { 1 }$ with true label $Y$ and classifier $f$ , Gu et al. (2019) studies the conditional probability $P ( f ( I _ { 1 } ) = y | f ( I _ { 0 } ) = y )$ 2. While PM-k looks for errors in all neighbor frames in a neighborhood of $k$ frames away from the anchor frame (so this would include frames $1 , 2 , \ldots , \mathbf { k }$ frames away), Gu et al. (2019) only considers errors from exactly $\mathbf { k }$ frames away.
+
+In Fig. 9 we illustrate simple example where two videos can have the same behavior for the metric introduced by Gu et al. (2019) but drastically different behavior for the PM-kmetric.
+
+![](images/b99b31eb80549a2ce5a146b9991ebb1a16332cc9fc396d70797ec3cc6548214e.jpg)  
+Figure 9: For the two example videos above the score from Gu et al. (2019) metric (Accuracy $\ @ \mathrm { ~ K ~ }$ ) is identical, but the PM- $\mathbf { \nabla } \cdot \mathbf { k }$ metric behaves substantially differently when the errors are spread across many independent videos, as shown in the right example
+
+# F $\ell _ { \infty }$ DISTANCE VS PM-K ACCURACY
+
+$\ell _ { \infty }$ adversarial examples are well studied in the robustness community, yet the connection between $\ell _ { \infty }$ and other forms of more “natural” robustness is unclear. Here, we plot the cumulative distribution of the $\ell _ { \infty }$ distance between pairs of nearby frames in our datasets. In Figure 10, we show the CDF of $\ell _ { \infty }$ distance for all pairs, all reviewed pairs, and mistakes made by 3 indicative models. Note the fbrobust model is trained specifically to be robust to $\ell _ { \infty }$ adversaries.
+
+![](images/a0fe913f4c1ab1426c7cfed965e1735fc0300673b84d41a7d2d5c94cdc30c67e.jpg)  
+Figure 10: CDF showing the $\ell _ { \infty }$ distance between pairs of frames from different distributions.
+
+Table 7: Analyzing results based on frame-type in video compression. See Appendix H.1 for details.   
+
+<table><tr><td></td><td>Original Acc.</td><td>Perturbed Acc.</td><td>A</td><td># anchor frames</td></tr><tr><td>All frames</td><td>84.8</td><td>70.2</td><td>14.6</td><td>1109</td></tr><tr><td>w/o‘i-frames&#x27;</td><td>84.7</td><td>70.3</td><td>14.4</td><td>1104</td></tr><tr><td>w/o ‘ ‘p-frames&#x27;</td><td>83.9</td><td>73.7</td><td>10.2</td><td>415</td></tr><tr><td>w/o ‘b-frames&#x27;</td><td>85.4</td><td>73.2</td><td>12.2</td><td>699</td></tr></table>
+
+# G PM-K ACCURACY WITH VARYING K
+
+G.1 IM A G ENE T-VI D-RO B U S T
+
+![](images/0a7c0a40f3c57359697c692f8bfed11ac08b2e1dba5ef16c54b85cea53126b9e.jpg)  
+Figure 11: Model classification accuracy on perturbed frames as a function of perturbation distance (shown with $9 5 \%$ Clopper-Pearson confidence intervals). Model accuracies from five different model types and the best performing model are shown. The model architecture is ResNet-50 unless otherwise mentioned.
+
+In Figure 11, we plot the relationship between $\mathrm { a c c } _ { \mathrm { p m k } }$ and perturbation distance (i.e., the $\mathrm { k }$ in the $\mathrm { p m - k }$ metric). The entire $\mathbf { X }$ -axis in Figure 11 corresponds to a temporal distance of at most 0.3 seconds between the original and perturbed frames.
+
+# H I-FRAMES AND P-FRAMES
+
+# H.1 IM A G ENE T-VI D-RO B U S T
+
+One possible concern with analyzing performance on video frames is the impact of video compression on model robustness. In particular, the videos in ImageNet-Vid-Robust contain 3 different frame types: ‘i-frames’, ‘p-frames’, and ‘b-frames’. ‘p-frames’ are compressed by referencing pixel content from previous frames, while ‘b-frames’ are compressed via references to previous and future frames. ‘i-frames’ are stored without references to other frames.
+
+We compute the original and perturbed accuracies, and the drop in accuracy for a subset of the dataset without ‘i-frames’, a subset without ‘p-frames’, and a subset without ‘b-frames’ in Table 7. While there are modest differences in accuracy due to compression, this analysis suggests that the sensitivity of models is not significantly due to the differences in quality of frames due to video compression.
+
+# I FPS ANALYSIS
+
+# I.1 IM A G ENE T-VI D-RO B U S T
+
+To analyze the impact of frame-rate on accuracy, we show results on subsets of videos with fixed fps (25, 29, and 30, which cover $89 \%$ of the dataset) using a fine-tuned ResNet-152 model in Table 8. The accuracy drop is similar across the subsets, and similar to the drop for the whole dataset.
+
+<table><tr><td>FPS</td><td>Acc. Orig.</td><td></td><td>Acc.Perturbed</td><td>Drop</td><td># Videos</td></tr><tr><td>25</td><td>87.3 [83.0, 90.9]</td><td>73.3</td><td>[67.8, 78.3]</td><td>14.0</td><td>292</td></tr><tr><td>29</td><td>87.7 [84.0, 90.8]</td><td>74.9</td><td>[70.3, 79.2]</td><td>12.8</td><td>383</td></tr><tr><td>30</td><td>78.3 [73.3, 82.7]</td><td></td><td>61.7 [56.0, 67.1]</td><td>16.6</td><td>313</td></tr></table>
+
+Table 8: Results on subsets of ImageNet-Vid-Robust with fixed FPS.
+
+# J ILSVRC TRAINING WITH IM A G ENE T-VI D-RO B U S T CLASSES
+
+We trained ResNet-50 from scratch on ILSVRC using the 30 ImageNet-Vid classes. We also finetuned the model on ImageNet-Vid. In Table 9, we show the accuracy drops are consistent with models in our submission. We hypothesize that the lower accuracy is due to coarser supervision on ILSVRC.   
+
+<table><tr><td>Model</td><td>Acc. Orig.</td><td>Acc. Perturbed</td><td>Drop</td></tr><tr><td>ILSVRC-30</td><td>61.0</td><td>44.9</td><td>15.1</td></tr><tr><td>ILSVRC-30 + FT</td><td>77.8</td><td>59.9</td><td>17.9</td></tr></table>
+
+Table 9: Results of training ResNet-50 on ILSVRC with 30 classes from ImageNet-Vid-Robust.
+
+# K EXPERIMENTAL DETAILS & HYPERPARAMETERS
+
+All classification experiments were carried out using PyTorch version 1.0.1 on an AWS p3.2xlarge with the NVIDIA V100 GPU. All pretrained models were downloaded from Cadene at commit hash $0 2 1 \mathtt { d } 9 7 8 9 7 \mathtt { c } 9 \mathtt { a } \mathtt { a } 7 6 \mathtt { e } \mathtt { c } 7 5 9 \mathtt { d } \mathtt { e } \mathtt { f } \mathtt { f } 4 3 \mathtt { d } 3 4 1 \mathtt { c } 4 \mathtt { f } \mathtt { d } 4 5 \mathtt { d } 7 \mathtt { b } \mathtt { a } .$ Evaluations in Table ?? all use the default settings for evaluation. The hyperparameters for the fine-tuned models are presented in Table 10. We searched for learning rates between $1 0 ^ { - 3 }$ and $1 0 ^ { - 5 }$ for all models.
+
+We additionally detail hyperparameters for detection models in Table 11. Detection experiments were conducted with PyTorch version 1.0.1 on a machine with 4 Titan X GPUs, using the Mask R-CNN benchmark repositoryMassa and Girshick (2018). We used the default learning rate provided in Massa and Girshick (2018). For R-FCN, we used the model trained by Xiao and Jae Lee (2018).
+
+Table 10: Hyperparameters for models finetuned on ImageNet-Vid,   
+Table 11: Hyperparameters for detection models.   
+
+<table><tr><td>Model</td><td>Base Learning Rate</td><td>Learning Rate Schedule</td><td></td><td>Batch Size</td><td>Epochs</td></tr><tr><td>resnet152</td><td>10-4</td><td>Reduce</td><td>LR On Plateau</td><td>32</td><td>10</td></tr><tr><td>resnet50</td><td>10-4</td><td>Reduce</td><td>LR On Plateau</td><td>32</td><td>10</td></tr><tr><td> alexnet</td><td>10-5</td><td>Reduce </td><td> LR On Plateau</td><td>32</td><td>10</td></tr><tr><td>vgg16</td><td>10-5</td><td>Reduce</td><td> LR On Plateau</td><td>32</td><td>10</td></tr></table>
+
+<table><tr><td>Model</td><td>Base Learning Rate</td><td>Learning Rate Schedule</td><td>Batch Size</td><td>Iterations</td></tr><tr><td>F-RCNN ResNet-50</td><td>10-2</td><td>Step 20k，30k</td><td>8</td><td>40k</td></tr><tr><td>F-RCNN ResNet-101</td><td>10-2</td><td>Step 20k，30k</td><td>8</td><td>40k</td></tr></table>
+
+# L DETECTION PM-K
+
+We briefly introduce the mAP metric for detection here and refer the reader to Lin et al. for further details. The standard detection metric proceeds by first determining whether each predicted bounding box in an image is a true or false positive, based on the intersection over union (IoU) of the predicted and ground truth bounding boxes. The metric then computes the per-category average precision (AP, averaged over recall thresholds) of the predictions across all images. The final metric is reported as the mean of these per-category APs (mAP).
+
+We define the $\mathrm { p m - k }$ analog of mAP by replacing each anchor frame in the dataset with a nearby frame that minimizes the per-image average precision. Since the category-specific average precision is undefined for categories not present in an image, we minimize the average precision across categories present in each frame rather than the mAP.

parse/train/Syx9ET4YPB/Syx9ET4YPB_content_list.json

@@ -0,0 +1,1818 @@
+[
+    {
+        "type": "text",
+        "text": "DO IMAGE CLASSIFIERS GENERALIZE ACROSS TIME? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            398,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            209,
+            544,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We study the robustness of image classifiers to temporal perturbations derived from videos. As part of this study, we construct ImageNet-Vid-Robust and YTBB-Robust, containing a total 57,897 images grouped into 3,139 sets of perceptually similar images. Our datasets were derived from ImageNet-Vid and Youtube-BB respectively and thoroughly re-annotated by human experts for image similarity. We evaluate a diverse array of classifiers pre-trained on ImageNet and show a median classification accuracy drop of 16 and 10 percent on our two datasets. Additionally, we evaluate three detection models and show that natural perturbations induce both classification as well as localization errors, leading to a median drop in detection mAP of 14 points. Our analysis demonstrates that perturbations occurring naturally in videos pose a substantial and realistic challenge to deploying convolutional neural networks in environments that require both reliable and low-latency predictions. ",
+        "bbox": [
+            233,
+            236,
+            764,
+            416
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            440,
+            336,
+            455
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolutional neural networks (CNNs) still exhibit many troubling failure modes. At one extreme, $\\ell _ { p }$ -adversarial examples cause large drops in accuracy for state-of-the-art models while relying only on visually imperceptible changes to the input image (Goodfellow et al., 2014; Biggio and Roli, 2018). However, this failure mode usually does not pose a problem outside a fully adversarial context because carefully crafted $\\ell _ { p }$ -perturbations are unlikely to occur naturally in the real world. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            542
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To study more realistic failure modes, researchers have investigated benign image perturbations such as rotations & translations, colorspace changes, and various image corruptions (Fawzi and Frossard, 2015; Engstrom et al., 2017; Fawzi and Frossard, 2015; Hendrycks and Dietterich, 2019). However, it is still unclear whether these perturbations reflect the robustness challenges arising in real data since the perturbations also rely on synthetic image modifications. ",
+        "bbox": [
+            174,
+            551,
+            825,
+            621
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent work has therefore turned to videos as a source of naturally occurring perturbations of images (Zheng et al., 2016; Azulay and Weiss, 2018; Gu et al., 2019). In contrast to other failure modes, the perturbed images are taken from existing image data without further modifications that make the task more difficult. As a result, robustness to such perturbations directly corresponds to performance improvements on real data. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            698
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, it is currently unclear to what extent such video perturbations pose a significant robustness challenge. Azulay and Weiss (2018) and Zheng et al. (2016) only provide anecdotal evidence from a small number of videos. Gu et al. (2019) go beyond individual videos and utilize a large video dataset (Real et al., 2017) in order to measure the effect of video perturbations more quantitatively. In their evaluation, the best image classifiers lose about $3 \\%$ accuracy for video frames up to 0.3 seconds away. However, the authors did not employ humans to review the frames in their videos. Hence the accuracy drop could also be caused by significant changes in the video frames (e.g., due to fast camera or object motion). Since the $3 \\%$ accuracy drop is small to begin with, it remains unclear whether video perturbations are a robustness challenge for current image classifiers. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            832
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We address these issues by conducting a thorough evaluation of robustness to natural perturbations arising in videos. As a cornerstone of our investigation, we introduce two test sets for evaluating model robustness: ImageNet-Vid-Robust and YTBB-Robust, carefully curated from the ImageNet-Vid and Youtube-BB datasets, respectively (Russakovsky et al., 2015; Real et al., 2017). All images in the two datasets were screened by a set of expert labelers to ensure high annotation quality and minimize selection biases that arise when filtering a dataset with CNNs. To the best of our knowledge these are the first datasets of their kind, containing tens of thousands of images that are human reviewed and grouped into thousands of perceptually similar sets. In total, our datasets contain 3,139 sets of temporally adjacent and visually similar images (57,897 images total). ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We then utilize these datasets to measure the accuracy of current CNNs to small, naturally occurring perturbations. Our testbed contains over 45 different models, varying both architecture and training methodology (adversarial training, data augmentation, etc.). To better understand the drop in accuracy due to natural perturbations, we also introduce a robustness metric that is more stringent than those employed in prior work. Under this metric, we find that natural perturbations from ImageNet-Vid-Robust and YTBB-Robust induce a median accuracy drop of $16 \\%$ and $10 \\%$ respectively for classification tasks and a median 14 point drop in mAP for detection tasks.1 Even for the best-performing classification models, we observe an accuracy drop of $14 \\%$ for ImageNet-Vid-Robust and $8 \\%$ for YTBB-Robust. ",
+        "bbox": [
+            173,
+            154,
+            825,
+            277
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our results show that robustness to natural perturbations in videos is indeed a significant challenge for current CNNs. As these models are increasingly deployed in safety-critical environments that require both high accuracy and low latency (e.g., autonomous vehicles), ensuring reliable predictions on every frame of a video is an important direction for future work. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            340
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/3f6b30513a9f6483b745608a87d39877b703a1ece944de817966f2872e542011.jpg",
+        "image_caption": [
+            "Figure 1: Three examples of natural perturbations from nearby video frames and resulting classifier confidences from a ResNet-152 model fine-tuned on ImageNet-Vid. While the images appear almost identical to the human eye, the classifier confidence changes substantially. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            354,
+            823,
+            486
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 CONSTRUCTING A TEST SET FOR ROBUSTNESS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            541,
+            598,
+            558
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "ImageNet-Vid-Robust and YTBB-Robust are sourced from videos in the ImageNet-Vid and Youtube-BB datasets (Russakovsky et al., 2015; Real et al., 2017). All object classes in ImageNet-Vid and Youtube-BB are from the WordNet hierarchy (Miller, 1995) and direct ancestors of ILSVRC-2012 classes. Using the WordNet hierarchy, we construct a canonical mapping from ILSVRC-2012 classes to ImageNet-Vid and Youtube-BB classes, which allows us to evaluate off-the-shelf ILSVRC-2012 models on ImageNet-Vid-Robust and YTBB-Robust. We provide more background on the source datsets in Appendix A. ",
+        "bbox": [
+            174,
+            573,
+            825,
+            671
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 CONSTRUCTING IM A G ENE T-VI D-RO B U S T AND YTBB-RO B U S T ",
+        "bbox": [
+            176,
+            689,
+            661,
+            702
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Next, we describe how we extracted sets of naturally perturbed frames from ImageNet-Vid and Youtube-BB to create ImageNet-Vid-Robust and YTBB-Robust. A straightforward approach would be to select a set of anchor frames and use temporally adjacent frames in the video with the assumption that such frames contain only small perturbations from the anchor. However, as Fig. 2 illustrates, this assumption is frequently violated, especially due to fast camera or object motion. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            784
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Instead, we first collect preliminary datasets of natural perturbations following the same approach, and then manually review each of the frame sets. For each video, we randomly sample an anchor frame and take $k = 1 0$ frames before and after the anchor frame as candidate perturbation images.2 This results in two datasets containing one anchor frame each from 3,139 videos, with approximately 20 candidate perturbation per anchor frame.3 ",
+        "bbox": [
+            174,
+            790,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/d9c52de0f9f2b2238ab572f72a307040e50e22ea95af85e046369fbc6ff7b8c5.jpg",
+        "image_caption": [
+            "Figure 2: Temporally adjacent frames may not be visually similar. We show three randomly sampled frame pairs where the nearby frame was marked as “dissimilar” to the anchor frame during human review and then discarded from our dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            820,
+            193
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/42739e81fb63e115b46ecd824e9d7195be73a1bd4dee15e9422ea4bb6b09a99c.jpg",
+        "table_caption": [
+            "Table 1: Statistics of ImageNet-Vid-Robust and YTBB-Robust. For YTBB-Robust, we updated the labels from for $41 \\%$ (834) of the accepted anchors due to labeling errors in Youtube-BB. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td>ImageNet-Vid-Robust</td><td>YTBB-Robust</td></tr><tr><td rowspan=\"3\">Anchor frames</td><td>Reviewed</td><td>1,314</td><td>2,467</td></tr><tr><td>Accepted</td><td>1,109 (84%)</td><td>2,030 (82%)</td></tr><tr><td>Labels updated</td><td>1</td><td>834 (41%)</td></tr><tr><td rowspan=\"2\">Frame pairs</td><td>Reviewed</td><td>26,029</td><td>45,631</td></tr><tr><td>Accepted</td><td>21,070 (80.9%)</td><td>36,827 (80.7%)</td></tr></table>",
+        "bbox": [
+            196,
+            260,
+            802,
+            352
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Next, we curate the dataset with the help of four expert human annotators. The goal of the curation step is to ensure that each anchor frame and its nearby frames are correctly labeled with the same ground truth class, and that the anchor frame and the nearby frames are visually similar. ",
+        "bbox": [
+            176,
+            417,
+            823,
+            459
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Denser labels for Youtube-BB. As Youtube-BB contains only a single category label per frame at 1 frame per second, annotators first viewed each anchor frame individually and marked any missing labels. In total, annotators corrected the labels for 834 frames, adding an average of 0.5 labels per anchor frame. These labels are then propagated to nearby, unlabeled frames at the native frame rate and verified in the next step. ImageNet-Vid densely labels all classes per frame, so we skip this step. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            536
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Frame pairs review. Next, for each pair of anchor and candidate perturbation frames, a human annotates (i) whether the pair is correctly labeled in the dataset, and (ii) whether the pair is similar. We took several steps to mitigate the subjectivity of this task and ensure high annotation quality. First, we trained reviewers to mark frames as dissimilar if the scene undergoes any of the following transformations: significant motion, significant background change, or significant blur change. We asked reviewers to mark each dissimilar frame with one of these transformations, or “other”, and to mark a pair of images as dissimilar if a distinctive feature of the object is only visible in one of the two frames (such as the face of a dog). If an annotator was unsure about the correct label, she could mark the pair as “unsure”. Second, we present only a single pair of frames at a time to reviewers because presenting videos or groups of frames could cause them to miss large changes due to the phenomenon of change blindness (Pashler, 1988). ",
+        "bbox": [
+            174,
+            542,
+            825,
+            696
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Verification. In the previous stage, all annotators were given identical labeling instructions and individually reviewed a total of 71,660 images pairs. To increase consistency in annotation, annotators jointly reviewed all frames marked as dissimilar, incorrectly labeled, or “unsure”. A frame was only considered similar to its anchor if a strict majority of the annotators marked the pair as such. ",
+        "bbox": [
+            174,
+            704,
+            825,
+            760
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "After the reviewing was complete, we discarded all anchor frames and candidate perturbations that annotators marked as dissimilar or incorrectly labeled. The final datasets contain a combined total of 3,139 anchor frames with a median of 20 similar frames each. ",
+        "bbox": [
+            174,
+            767,
+            823,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 THE P M-K EVALUATION METRIC ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            827,
+            437,
+            842
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given the datasets introduced above, we propose a metric to measure a model’s robustness to natural perturbations. In particular, let $A = \\{ a _ { 1 } , . . . , a _ { n } \\}$ be the set of valid anchor frames in our dataset. Let $Y = \\{ y _ { 1 } , . . . , y _ { n } \\}$ be the set of labels for $A$ . We let $\\textstyle { \\mathcal { N } } _ { k } ( a _ { i } )$ be the set of frames marked as similar to anchor frame $a _ { i }$ . In our setting, $\\mathcal { N } _ { k }$ is a subset of the $2 k$ temporally adjacent frames (plus/minus $\\mathbf { k }$ frames from the anchor). ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Classification. Classification accuracy is defined as $\\begin{array} { r } { \\mathrm { a c c } _ { \\mathrm { o r i g } } = 1 - \\frac { 1 } { N } \\sum _ { i = 0 } ^ { N } \\mathcal { L } _ { 0 / 1 } ( f ( a _ { i } ) , y _ { i } ) } \\end{array}$ , where $\\mathcal { L } _ { 0 / 1 }$ is the standard 0-1 loss function. We define the $\\mathrm { p m - k }$ analog of accuracy as ",
+        "bbox": [
+            173,
+            101,
+            825,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/71701e6adb581e0f883f201bedca69f386a5fac163fdf05b2c7fd2e3e8fc5c13.jpg",
+        "text": "$$\n\\mathrm { a c c } _ { \\mathrm { p m k } } = 1 - \\frac { 1 } { N } \\sum _ { i = 0 } ^ { N } \\operatorname* { m a x } _ { b \\in \\mathcal { N } _ { k } ( a _ { i } ) } \\mathcal { L } _ { 0 / 1 } ( f ( b ) , y _ { i } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            143,
+            655,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "which corresponds to picking the worst frame from each set $\\textstyle { \\mathcal { N } } _ { k } ( a _ { i } )$ before computing accuracy. ",
+        "bbox": [
+            173,
+            196,
+            800,
+            212
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Detection. The standard metric for detection is mean average precision (mAP) of the predictions at a fixed intersection-over-union (IoU) threshold Lin et al. (2014). We define the $\\mathrm { p m - k }$ metric analogous to that for classification: We replace each anchor frame with the nearest frame that minimizes the average precision (AP, averaged over recall thresholds) of the predictions, and compute $\\mathrm { p m - k }$ as the mAP on these worst-case neighboring frames. ",
+        "bbox": [
+            173,
+            232,
+            825,
+            304
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 MAIN RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            330,
+            333,
+            345
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/ce35b09ba50d55d64192d79ef52cb386fa1ca0e6d3e8f2da696a1913a871875d.jpg",
+        "image_caption": [
+            "Figure 3: Model accuracy on original vs. perturbed images. Each data point corresponds to one model in our testbed (shown with $9 5 \\%$ Clopper-Pearson confidence intervals). Each perturbed frame was taken from a ten frame neighborhood of the original frame (approximately 0.3 seconds). All frames were reviewed by humans to confirm visual similarity to the original frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            369,
+            759,
+            561
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We evaluate a testbed of 45 classification and three detection models on ImageNet-Vid-Robust and YTBB-Robust. We first discuss the various types of classification models evaluated with the $\\mathrm { p m - k }$ classification metric. Second, we evaluate the performance of detection models on ImageNet-Vid-Robust using use the bounding box annotations inherited from ImageNet-Vid using a variant of $\\mathrm { p m - k }$ for detection. We then analyze the errors made on the detection adversarial examples to isolate the effects of localization errors vs. classification errors. ",
+        "bbox": [
+            174,
+            650,
+            825,
+            733
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            757,
+            331,
+            771
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The classification robustness metric is $\\mathrm { a c c } _ { \\mathrm { p m k } }$ defined in Equation (1). For frames with multiple labels, we count a prediction as correct if the model predicts any of the correct classes for a frame. In Figure 3, we plot the benign accuracy, $\\operatorname { a c c } _ { \\mathrm { o r i g } }$ , versus the robust accuracy, $\\mathrm { a c c } _ { \\mathrm { p m k } }$ , for all classification models in our test bed and find that the relationship between $\\operatorname { a c c } _ { \\mathrm { o r i g } }$ and $\\mathrm { a c c } _ { \\mathrm { p m k } }$ is approximately linear. This relationship indicates that improvements in the benign accuracy do result in improvements in the worst-case accuracy, but do not suffice to resolve the accuracy drop due to natural perturbations. ",
+        "bbox": [
+            173,
+            787,
+            825,
+            872
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our test bed consists of five model types with increasing levels of supervision. We present results for representative models from each model type in Table 2 and defer the full classification results table to Appendix B.2. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/93504e29d42d2d6cda7c44c90142ee15e467a45dfec98b321b9089ed326f2725.jpg",
+        "table_caption": [
+            "Table 2: Accuracies of five different model types and the best performing model. The model architecture is ResNet-50 unless noted otherwise. ‘FT’ is ‘fine-tuning.’ See Section 3.1 for details. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=3>Model Type                                  Accuracy          Accuracy        △PerturbedOriginal</td></tr><tr><td rowspan=1 colspan=3>ImageNet-Vid-Robust</td></tr><tr><td rowspan=1 colspan=3>Trained on ILSVRC                     67.5 [64.7, 70.3]  52.5 [49.5, 55.5]  15.0</td></tr><tr><td rowspan=1 colspan=3> + Noise Augmentation                  68.8 [66.0, 71.5]  53.2 [50.2, 56.2]  15.6</td></tr><tr><td rowspan=1 colspan=3>+lrobustness (ResNext-101)        54.3 [51.3, 57.2]  40.8 [39.0, 43.7]  12.4</td></tr><tr><td rowspan=1 colspan=3> + FT on ImageNet- Vid                  80.8 [78.3, 83.1]  65.7 [62.9, 68.5]  15.1</td></tr><tr><td rowspan=1 colspan=1>+ FT on ImageNet-Vid (ResNet-152)  84.8 [82.5, 86.8]</td><td rowspan=1 colspan=2>70.2 [67.4, 72.8]  14.6</td></tr><tr><td rowspan=1 colspan=3> + FT on ImageNet-Vid-Det             77.6 [75.1, 80.0]  65.4 [62.5, 68.1]  12.3</td></tr><tr><td rowspan=1 colspan=3>YTBB-Robust</td></tr><tr><td rowspan=1 colspan=1>Trained on ILSVRC                     57.0 [54.9, 59.2]</td><td rowspan=1 colspan=2>43.8 [41.7, 46.0]  13.2</td></tr><tr><td rowspan=1 colspan=1>+Noise Augmentation                  62.3 [60.2, 64.4]</td><td rowspan=1 colspan=1>45.7 [43.5, 47.9]</td><td rowspan=1 colspan=1>16.6</td></tr><tr><td rowspan=1 colspan=1> + l robustness (ResNext-101)        53.6 [51.4, 55.8]</td><td rowspan=1 colspan=1>43.2 [41.0, 45.3]</td><td rowspan=1 colspan=1>10.4</td></tr><tr><td rowspan=1 colspan=1>+ FT on Youtube-BB                    91.4 [90.1, 92.6]</td><td rowspan=1 colspan=1>82.0 [80.3, 83.7]</td><td rowspan=1 colspan=1>9.4</td></tr><tr><td rowspan=1 colspan=1> + FT on Youtube-BB (ResNet-152)    92.9 [91.6, 93.9]</td><td rowspan=1 colspan=1>84.7 [83.0, 86.2]</td><td rowspan=1 colspan=1>8.2</td></tr></table>",
+        "bbox": [
+            220,
+            140,
+            777,
+            361
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "ILSVRC Trained The WordNet hierarchy enables us to repurpose models trained for the 1,000 class ILSVRC dataset on ImageNet-Vid-Robust and YTBB-Robust (see Appendix A.1). We evaluate a wide array of ILSVRC-2012 models (available from Cadene) against our natural perturbations. Since these datasets present a substantial distribution shift from the original ILSVRC2012 validation, we expect the benign accuracy $\\operatorname { a c c } _ { \\mathrm { o r i g } }$ to be lower than the comparable accuracy on the ILSVRC-2012 validation set. However, our main interest here is in the difference between the original and perturbed accuracies $\\operatorname { a c c } _ { \\mathrm { o r i g } } - \\operatorname { a c c } _ { \\mathrm { p m k } }$ . A small drop in accuracy would indicate that the model is robust to small changes that occur naturally in videos. Instead, we find significant drops of $1 5 . 0 \\%$ and $1 3 . 2 \\%$ in accuracy on our two datasets, indicating sensitivity to such changes. ",
+        "bbox": [
+            173,
+            382,
+            825,
+            508
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Noise augmentation One hypothesis for the accuracy drop from original to perturbed accuracy is that subtle artifacts and corruptions introduced by video compression schemes could degrade performance when evaluating on these corrupted frames. The worst-case nature of the $\\mathrm { p m - k }$ metric could then be focusing on these corrupted frames. One model for these corruptions are the perturbations introduced in Hendrycks and Dietterich (2019). To test this hypothesis, we evaluate models augmented with a subset of the perturbations (exactly one of: Gaussian noise, Gaussian blur, shot noise, contrast change, impulse noise, or JPEG compression). We found that these augmentation schemes did not improve robustness against our perturbations substantially, and still result in accuracy drop of $1 5 . 6 \\%$ and $1 6 . 6 \\%$ on the two datasets. ",
+        "bbox": [
+            173,
+            517,
+            825,
+            642
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\ell _ { \\infty }$ robustness. We evaluate the model from Xie et al. (2018), which currently performs best against $\\ell _ { \\infty }$ attacks on ImageNet. We find that this model has a smaller accuracy drop than the two aforementioned model types on both datasets. However, we note that the robust model achieves significantly lower original and perturbed accuracy than either of the two model types above, and the robustness gain is modest $3 \\%$ compared to models of similar benign accuracy). ",
+        "bbox": [
+            174,
+            651,
+            825,
+            722
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Fine-tuning on video frames. To adapt to the new class vocabulary and the video domain, we fine-tune several network architectures on the ImageNet-Vid and Youtube-BB training sets. For Youtube-BB, we train on the anchor frames used for training in Gu et al. (2019), and for ImageNet-Vid we use all frames in the training set. We provide hyperparameters for all models in Appendix K. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            787
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The resulting models significantly improve in accuracy over their ILSVRC pre-trained counterparts (e.g., $13 \\%$ on ImageNet-Vid-Robust and $34 \\%$ on YTBB-Robust for ResNet-50). This improvement in accuracy results in a modest improvement in the accuracy drop for YTBB-Robust, but a finetuned ResNet-50 still suffers from a significant $9 . 4 \\%$ drop. On ImageNet-Vid-Robust, there is almost no change in the accuracy drop from $1 5 . 0 \\%$ to $1 5 . 1 \\%$ . ",
+        "bbox": [
+            176,
+            789,
+            826,
+            858
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Fine-tuning for detection on video frames. We further analyze whether additional supervision in the form of bounding box annotations improves robustness. To this end, we train the Faster R-CNN detection model Ren et al. (2015) with a ResNet-50 backbone on ImageNet-Vid. Following standard practice, the detection backbone is pre-trained on ILSVRC-2012. To evaluate this detector for classification, we assign the class with the most confident bounding box as label to the image. We find that this transformation reduces accuracy compared to the model trained for classification $( 7 7 . 6 \\%$ vs. $8 0 . 8 \\%$ ). While there is a slight reduction in the accuracy drop caused by natural perturbations, the reduction is well within the error bars for this test set. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 DETECTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            172,
+            297,
+            185
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We further study the impact of natural perturbations on object detection. Specifically, we report results for two related tasks: object localization and detection. Object detection is the standard computer vision task of correctly classifying an object and finding the coordinates of a tight bounding box containing the object. “Object localization”, meanwhile, refers to only the subtask of finding the bounding box, without attempting to correctly classify the object. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            263
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We present our results on ImageNet-Vid-Robust, which contains dense bounding box labels unlike Youtube-BB, which only labels boxes at 1 frame per second. We use the popular Faster R-CNN Ren et al. (2015) and R-FCN Dai et al. (2016); Xiao and Jae Lee (2018) architectures for object detection and localization and report results in Table 3. For the R-FCN architecture, we use the model from Xiao and Jae Lee $( 2 0 1 8 ) ^ { 4 }$ . We first note the significant drop in mAP of 12 – 15 points for object detection due to perturbed frames for both the Faster R-CNN and R-FCN architectures. Next, we show that localization is indeed easier than detection, as the mAP is higher for localization than for detection (e.g., 76.6 vs 62.8 for Faster R-CNN with a ResNet-50 backbone). Perhaps surprisingly, however, switching to the localization task does not improve the drop between original and perturbed frames, indicating that natural perturbations induce both classification and localization errors. We show examples of detection failures in Figure 4. ",
+        "bbox": [
+            173,
+            265,
+            825,
+            416
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/66cd8c2b8564417377f00f08cfec935c33d0a2cce3d3f68b46ab2790725206ef.jpg",
+        "image_caption": [
+            "Figure 4: Naturally perturbed examples for detection. Red boxes indicate false positives; green boxes indicate true positives; white boxes are ground truth. Classification errors are common failures, such as the fox on the left, which is classified correctly in the anchor frame, and misclassified as a sheep in a nearby frame. However, detection models also have localization errors, where the object of interest is not correctly localized in addition to being misclassified, such as the airplane (middle) and the motorcycle (right). All visualizations show predictions with confidence greater than 0.5. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            433,
+            823,
+            656
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 IMPACT OF DATASET REVIEW ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            781,
+            419,
+            796
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We analyze the impact of our human review, described in Section 2.1, on the classifiers in our test bed. First, we compare the original and perturbed accuracies of a representative classifier (ResNet152 finetuned) with and without review in Table 4. Our review improves the original accuracy by $3- 4 \\%$ by throwing away mislabeled or blurry anchor frames, and improves perturbed accuracy by $5- 6 \\%$ by discarding pairs of dissimilar frames. Our review reduces the accuracy drop by $1 . 8 \\%$ on ",
+        "bbox": [
+            174,
+            803,
+            825,
+            872
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/c2b153dbc59f4a6a3de61b2c6419c00fdb6229044a2820da8f869a81e0d00d35.jpg",
+        "table_caption": [
+            "Table 3: Detection and localization mAP for two Faster R-CNN backbones. Both detection and localization suffer from significant drops in mAP due to the perturbations. (\\*Model trained on ILSVRC Det and VID 2015 datasets, and evaluated on the 2015 subset of ILSVRC-VID 2017.) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>Model</td><td>mAP Original</td><td>mAP Perturbed</td><td>mAP △</td></tr><tr><td rowspan=\"3\">Detection</td><td>FRCNN,ResNet5</td><td>62.8</td><td>48.8</td><td>14.0</td></tr><tr><td>FRCNN,ResNet 101</td><td>63.1</td><td>50.6</td><td>12.5</td></tr><tr><td> R-FCN, ResNet 101 Xiao and Jae Lee (2018)*</td><td>79.4*</td><td>63.7*</td><td>15.7*</td></tr><tr><td rowspan=\"3\">Localization</td><td>FRCNN,ResNet50</td><td>76.6</td><td>64.2</td><td>12.4</td></tr><tr><td>FRCNN, ResNet 101</td><td>77.8</td><td>66.3</td><td>11.5</td></tr><tr><td>R-FCN, ResNet 101*</td><td>80.9*</td><td>70.3*</td><td>10.6*</td></tr></table>",
+        "bbox": [
+            181,
+            154,
+            812,
+            277
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ImageNet-Vid-Robust and $1 . 1 \\%$ on YTBB-Robust, but still results in large accuracy drops. These results indicate that the changes in model predictions are indeed due to a lack of robustness, rather than due to significant differences between adjacent frames. ",
+        "bbox": [
+            174,
+            300,
+            826,
+            342
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To further analyze the impact of our review on model errors, we plot how frequently each offset distance from the anchor frame results in a model error across all model types in Figure 5. For both datasets, larger offsets (indicating pairs of frames further apart in time) lead to more frequent model errors. Our review reduces the fraction of errors across offsets, and especially for large offsets, which are more likely to display large changes from the anchor frame. ",
+        "bbox": [
+            173,
+            344,
+            825,
+            414
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/4b62cf4ea50e313e218a252c96d0090fbe0855c3e30a90a9d4f5afba62738b13.jpg",
+        "image_caption": [
+            "Figure 5: We plot the fraction of times each offset caused an error, across all evaluated models, for frames with and without review. Frames further away more frequently cause classifiers to misfire. Our review process reduces the number of errors, especially for frames further in time, by removing dissimilar frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            429,
+            810,
+            546
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Impact of human review on original and perturbed accuracies for ImageNet-Vid-Robust and YTBB-Robust, using a ResNet-152 fine-tuned on ImageNet-Vid and Youtube-BB, respectively. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            688
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/48afc593d89772a086acd629e6791e7422ec23664f90b8b4acd9efdc5200f183.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"4\">Accuracy</td></tr><tr><td></td><td>Reviewed</td><td>Original</td><td>Perturbed</td><td>Drop</td></tr><tr><td rowspan=\"2\">ImageNet-Vid-Robust</td><td></td><td>80.3</td><td>64.1</td><td>16.2</td></tr><tr><td>X</td><td>84.8</td><td>70.2</td><td>14.4</td></tr><tr><td rowspan=\"2\">YTBB-Robust</td><td></td><td>88.1</td><td>78.1</td><td>10.0</td></tr><tr><td>X</td><td>92.9</td><td>84.7</td><td>8.9</td></tr></table>",
+        "bbox": [
+            245,
+            699,
+            748,
+            789
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            815,
+            341,
+            830
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Adversarial examples. While various forms of adversarial examples have been studied, the majority of research focuses on $\\ell _ { p }$ robustness Goodfellow et al. (2014); Biggio and Roli (2018). However, it is unclear whether adversarial examples pose a problem for classifier robustness outside of a truly worst case context. It is an open question whether perfect robustness against a $\\ell _ { p }$ adversary will induce robustness to realistic image distortions such as those studied in this paper. Recent work has proposed more realistic image modifications such as small rotations $\\&$ translations Engstrom et al. ",
+        "bbox": [
+            173,
+            840,
+            826,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(2017); Azulay and Weiss (2018); Fawzi and Frossard (2015); Kanbak et al. (2017), hue and color changes Hosseini and Poovendran (2018), image stylization Geirhos et al. (2018a) and synthetic image corruptions such as Gaussian blur and JPEG compression Hendrycks and Dietterich (2019); Geirhos et al. (2018b). Even though the above examples are more realistic than the $\\ell _ { p }$ model, they still synthetically modify the input images to generate perturbed versions. In contrast, our work performs no synthetic modification and instead uses images that naturally occur in videos. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Utilizing videos to study robustness. In work concurrent to ours, Gu et al. (2019) exploit the temporal structure in videos to study robustness. However, their experiments suggest a substantially smaller drop in classification accuracy. The primary reason for this is a less stringent metric used in Gu et al. (2019). By contrast, our “pm-k” metric is inspired by the “worst-of-k” metric used in prior work Engstrom et al. (2017), highlighting the sensitivity of models to natural perturbations. In Appendix E we study the differences between the two metrics in more detail. Furthermore, the lack of human review and the high label error-rate we discovered in Youtube-BB(Table 1) presents a troubling confounding factor that we resolve in our work. ",
+        "bbox": [
+            174,
+            200,
+            825,
+            311
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Distribution shift. Small, benign changes in the test distribution are often referred to as distribution shift. Recht et al. (2019) explore this phenomenon by constructing new test sets for CIFAR-10 and ImageNet and observe performance drops for a large suite of models on the newly constructed test sets. Similar to our Figure 3, the relationship between original and new test set accuracy is also approximately linear. However, the images in their test set bear little visual similarity to images in the original test set, while all of our failure cases in ImageNet-Vid-Robust and YTBB-Robust are on perceptually similar images. In a similar vein of study, Torralba et al. (2011) studies distribution shift across different computer vision data sets such as Caltech-101, PASCAL, and ImageNet. ",
+        "bbox": [
+            174,
+            324,
+            825,
+            435
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Computer vision. A common issue when applying image based models to videos is flickering, where object detectors spuriously produce false-positives or false-negatives in isolated frames or groups of frames. Jin et al. (2018) explicitly identify such failures and use a technique reminiscent of adversarially robust training to improve image-based models. A similar line of work focuses on improving object detection in videos as objects become occluded or move quickly Kang et al. (2017); Feichtenhofer et al. (2017); Zhu et al. (2017); Xiao and Jae Lee (2018). The focus in this line of work has generally been on improving object detection when objects transform in a way that makes recognition difficult from a single frame, such as fast motion or occlusion. In this work, we document a broader set of failure cases for image-based classifiers and detectors and show that failures occur when the neighboring frames are imperceptibly different. ",
+        "bbox": [
+            174,
+            448,
+            825,
+            588
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            606,
+            318,
+            621
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our study quantifies the sensitivity of image classifiers to naturally occuring temporal perturbations. We show that these perturbations can cause significant drops in accuracy for a wide range of models for both classification and detection. Our work on analyzing this failure mode opens multiple avenues for future research: ",
+        "bbox": [
+            174,
+            632,
+            825,
+            688
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Building more robust models. Our ImageNet-Vid-Robust and YTBB-Robust datasets provide a standard measure for robustness that can be applied to any classification or detection model. In Table 2, we evaluated several commonly used models and found that all of them suffer from substantial accuracy drops due to natural perturbations. In particular, we found that model improvements with respect to artificial perturbations (such as image corruptions or $\\ell _ { \\infty }$ adversaries) induce at best modest improvements in robustness. We hope that our standardized datasets and evaluation metric will enable future work to quantify improvements in natural robustness directly. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            799
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Further natural perturbations. Videos provide a straightforward method for collecting natural perturbations of images, admitting the study of realistic forms of robustness for machine learning methods. Other methods for generating these natural perturbations are likely to provide additional insights into model robustness. As an example, photo sharing websites contain a large number of near-duplicate images: pairs of images of the same scene captured at different times, viewpoints, or from a different camera Recht et al. (2019). More generally, devising similar, domain-specific strategies to collect, verify, and measure robustness to natural perturbations in domains such as natural language processing or speech recognition is a promising direction for future work. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aharon Azulay and Yair Weiss. Why do deep convolutional networks generalize so poorly to small image transformations? arXiv preprint arXiv:1805.12177, 2018. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Luca Bertinetto, Jack Valmadre, Joao F Henriques, Andrea Vedaldi, and Philip HS Torr. Fullyconvolutional siamese networks for object tracking. In European conference on computer vision, pages 850–865. Springer, 2016. ",
+        "bbox": [
+            174,
+            164,
+            825,
+            207
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Battista Biggio and Fabio Roli. Wild patterns: Ten years after the rise of adversarial machine learning. Pattern Recognition, 2018. https://arxiv.org/abs/1712.03141. ",
+        "bbox": [
+            171,
+            215,
+            823,
+            244
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Remi Cadene. Pretrained models for pytorch. https://github.com/Cadene/pretrain ed-models.pytorch. Accessed: 2019-05-20. ",
+        "bbox": [
+            171,
+            253,
+            823,
+            282
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jifeng Dai, Yi Li, Kaiming He, and Jian Sun. R-fcn: Object detection via region-based fully convolutional networks. In Advances in neural information processing systems, pages 379–387, 2016. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            333
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Logan Engstrom, Brandon Tran, Dimitris Tsipras, Ludwig Schmidt, and Aleksander Madry. A rotation and a translation suffice: Fooling cnns with simple transformations. arXiv preprint arXiv:1712.02779, 2017. ",
+        "bbox": [
+            173,
+            342,
+            825,
+            386
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alhussein Fawzi and Pascal Frossard. Manitest: Are classifiers really invariant? In British Machine Vision Conference (BMVC), 2015. ",
+        "bbox": [
+            171,
+            393,
+            823,
+            424
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christoph Feichtenhofer, Axel Pinz, and Andrew Zisserman. Detect to track and track to detect. In Proceedings of the IEEE International Conference on Computer Vision, pages 3038–3046, 2017. ",
+        "bbox": [
+            174,
+            433,
+            823,
+            462
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Robert Geirhos, Patricia Rubisch, Claudio Michaelis, Matthias Bethge, Felix A Wichmann, and Wieland Brendel. Imagenet-trained cnns are biased towards texture; increasing shape bias improves accuracy and robustness. arXiv preprint arXiv:1811.12231, 2018a. ",
+        "bbox": [
+            174,
+            469,
+            823,
+            513
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Robert Geirhos, Carlos RM Temme, Jonas Rauber, Heiko H Schütt, Matthias Bethge, and Felix A Wichmann. Generalisation in humans and deep neural networks. In Advances in Neural Information Processing Systems, pages 7538–7550, 2018b. ",
+        "bbox": [
+            173,
+            522,
+            825,
+            565
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014. ",
+        "bbox": [
+            173,
+            574,
+            823,
+            603
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Keren Gu, Brandon Yang, Jiquan Ngiam, Quoc Le, and Jonathan Shlens. Using videos to evaluate image model robustness. arXiv preprint arXiv:1904.10076, 2019. ",
+        "bbox": [
+            173,
+            611,
+            823,
+            642
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wei Han, Pooya Khorrami, Tom Le Paine, Prajit Ramachandran, Mohammad Babaeizadeh, Honghui Shi, Jianan Li, Shuicheng Yan, and Thomas S Huang. Seq-nms for video object detection. arXiv preprint arXiv:1602.08465, 2016. ",
+        "bbox": [
+            176,
+            650,
+            823,
+            693
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. arXiv preprint arXiv:1903.12261, 2019. ",
+        "bbox": [
+            171,
+            702,
+            823,
+            731
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hossein Hosseini and Radha Poovendran. Semantic adversarial examples. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pages 1614–1619, 2018. ",
+        "bbox": [
+            173,
+            739,
+            825,
+            782
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "SouYoung Jin, Aruni RoyChowdhury, Huaizu Jiang, Ashish Singh, Aditya Prasad, Deep Chakraborty, and Erik Learned-Miller. Unsupervised hard example mining from videos for improved object detection. In ECCV, 2018. ",
+        "bbox": [
+            176,
+            791,
+            825,
+            834
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Can Kanbak, Seyed-Mohsen Moosavi-Dezfooli, and Pascal Frossard. Geometric robustness of deep networks: analysis and improvement. arXiv preprint arXiv:1711.09115, 2017. ",
+        "bbox": [
+            171,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kai Kang, Hongsheng Li, Tong Xiao, Wanli Ouyang, Junjie Yan, Xihui Liu, and Xiaogang Wang. Object detection in videos with tubelet proposal networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 727–735, 2017. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. MS COCO detection evaluation. http://cocodataset.or g/#detection-eval. Accessed: 2019-05-16. ",
+        "bbox": [
+            176,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In European conference on computer vision, pages 740–755. Springer, 2014. ",
+        "bbox": [
+            178,
+            155,
+            823,
+            198
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Francisco Massa and Ross Girshick. maskrcnn-benchmark: Fast, modular reference implementation of Instance Segmentation and Object Detection algorithms in PyTorch. https://github.c om/facebookresearch/maskrcnn-benchmark, 2018. Accessed: 2019-05-20. ",
+        "bbox": [
+            174,
+            207,
+            826,
+            250
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "George A Miller. Wordnet: a lexical database for english. Communications of the ACM, 38(11): 39–41, 1995. ",
+        "bbox": [
+            173,
+            257,
+            823,
+            286
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Harold Pashler. Familiarity and visual change detection. Perception & psychophysics, 44(4):369–378, 1988. ",
+        "bbox": [
+            173,
+            295,
+            825,
+            324
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Esteban Real, Jonathon Shlens, Stefano Mazzocchi, Xin Pan, and Vincent Vanhoucke. Youtubeboundingboxes: A large high-precision human-annotated data set for object detection in video. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5296–5305, 2017. ",
+        "bbox": [
+            173,
+            333,
+            826,
+            390
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do imagenet classifiers generalize to imagenet? arXiv preprint arXiv:1902.10811, 2019. ",
+        "bbox": [
+            173,
+            398,
+            823,
+            428
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In Advances in neural information processing systems, pages 91–99, 2015. ",
+        "bbox": [
+            174,
+            435,
+            826,
+            479
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li FeiFei. ImageNet Large Scale Visual Recognition Challenge. IJCV, 115(3):211–252, 2015. doi: 10.1007/s11263-015-0816-y. ",
+        "bbox": [
+            174,
+            488,
+            826,
+            545
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Antonio Torralba, Alexei A Efros, et al. Unbiased look at dataset bias. In CVPR, volume 1, page 7. Citeseer, 2011. ",
+        "bbox": [
+            171,
+            553,
+            825,
+            583
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Fanyi Xiao and Yong Jae Lee. Video object detection with an aligned spatial-temporal memory. In Proceedings of the European Conference on Computer Vision (ECCV), pages 485–501, 2018. ",
+        "bbox": [
+            173,
+            592,
+            825,
+            621
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cihang Xie, Yuxin Wu, Laurens van der Maaten, Alan Yuille, and Kaiming He. Feature denoising for improving adversarial robustness. arXiv preprint arXiv:1812.03411, 2018. ",
+        "bbox": [
+            171,
+            628,
+            823,
+            659
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stephan Zheng, Yang Song, Thomas Leung, and Ian Goodfellow. Improving the robustness of deep neural networks via stability training. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), Jun 2016. doi: 10.1109/cvpr.2016.485. URL http://dx.doi.org/10. 1109/cvpr.2016.485. ",
+        "bbox": [
+            174,
+            666,
+            826,
+            723
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xizhou Zhu, Yujie Wang, Jifeng Dai, Lu Yuan, and Yichen Wei. Flow-guided feature aggregation for video object detection. In Proceedings of the IEEE International Conference on Computer Vision, pages 408–417, 2017. ",
+        "bbox": [
+            174,
+            732,
+            825,
+            775
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A SOURCE DATASET OVERVIEW ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            102,
+            457,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1 IMAGENET-VID ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            127,
+            330,
+            142
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The 2015 ImageNet-Vid dataset is widely used for training video object detectors Han et al. (2016) as well as trackers Bertinetto et al. (2016). We chose to work with the 2017 ImageNet-Vid dataset because it is a superset of the 2015 dataset. In total, the 2017 ImageNet-Vid dataset consists of 1,181,113 training frames from 4,000 videos and 512,360 validation frames from 1,314 videos. The videos have frame rates ranging from 9 to 59 frames per second (fps), with a median fps of 29. The videos range from 0.44 to 96 seconds in duration with a median duration of 12 seconds. Each frame is annotated with labels indicating the presence or absence of 30 object classes and corresponding bounding boxes for any label present in the frame. The 30 classes are ancestors of 293 of the 1,000 ILSVRC-2012 classes. ",
+        "bbox": [
+            173,
+            147,
+            825,
+            272
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.2 YOUTUBE-BB",
+        "text_level": 1,
+        "bbox": [
+            176,
+            285,
+            318,
+            299
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The 2017 Youtube-BB is a a large scale dataset with 8,146,143 annotated training frames 253,569 unique videos and with 1,013,246 validation frames from 31,829 videos. The video segments are approximately 19 seconds long on average. Each frame is annotated with exactly one label indicating the presence of 22 object classes, all of which are ancestors of 229 out of the ILSVRC-2012 classes. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            361
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B FULL ORIGINAL VS PERTURBED ACCURACIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            376,
+            593,
+            392
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B.1 IM A G ENE T-VI D-RO B U S T ",
+        "bbox": [
+            176,
+            402,
+            403,
+            415
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/89702fa7f8d9b77b993f13d6a782bdb2d00fa5050734a4dd25b704a07c18de18.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Accuracy Original</td><td>Accuracy Perturbed</td><td></td><td>△</td></tr><tr><td>resnet152_finetuned</td><td>84.8 [82.5, 86.8]</td><td></td><td>70.2 [67.4, 72.8]</td><td>14.6</td></tr><tr><td>resnet50_finetuned</td><td>80.8 [78.3, 83.1]</td><td></td><td>65.7 [62.9, 68.5]</td><td>15.1</td></tr><tr><td> vgg16bn_finetuned</td><td>78.0 [75.4, 80.4]</td><td></td><td>61.0 [58.1, 63.9]</td><td>17.0</td></tr><tr><td> nasnetalarge_imagenet_pretrained</td><td>77.6 [75.1, 80.1]</td><td></td><td>62.1 [59.2, 65.0]</td><td>15.5</td></tr><tr><td>resnet50_detection</td><td>77.6 [75.1, 80.1]</td><td></td><td>65.0 [62.1, 67.8]</td><td>12.6</td></tr><tr><td>inceptionresnetv2_imagenet_pretrained</td><td>75.7 [73.1, 78.2]</td><td></td><td>58.7 [55.7, 61.6]</td><td>17.0</td></tr><tr><td>dpn107_imagenet_pretrained</td><td>75.6 [72.9, 78.1]</td><td></td><td>59.1 [56.1, 62.0]</td><td>16.5</td></tr><tr><td>inceptionv4_imagenet_pretrained</td><td>75.3 [72.6, 77.8]</td><td></td><td>59.0 [56.0, 61.9]</td><td>16.3</td></tr><tr><td>dpn92_imagenet_pretrained</td><td>74.4 [71.7, 76.9]</td><td></td><td>56.8 [53.8, 59.7]</td><td>17.6</td></tr><tr><td>dpn131_imagenet_pretrained</td><td>74.0 [71.3, 76.6]</td><td></td><td>59.9 [56.9, 62.8]</td><td>14.1</td></tr><tr><td> dpn68b_imagenet_pretrained</td><td>73.7 [71.0, 76.2]</td><td></td><td>54.0 [51.0, 57.0]</td><td>19.7</td></tr><tr><td>resnext101_32x4d_imagenet_pretrained</td><td>73.3 [70.6, 75.9]</td><td></td><td>57.2 [54.2, 60.1]</td><td>16.1</td></tr><tr><td> resnext101_64x4d_imagenet_pretrained</td><td>72.9 [70.1, 75.5]</td><td></td><td>56.6 [53.7, 59.6]</td><td>16.3</td></tr><tr><td>resnet152_imagenet_pretrained</td><td>72.8 [70.0, 75.4]</td><td></td><td>57.0 [54.0, 59.9]</td><td>15.8</td></tr><tr><td> resnet1O1_imagenet_pretrained</td><td>71.5 [68.7, 74.1]</td><td></td><td>53.7 [50.8, 56.7]</td><td>17.8</td></tr><tr><td>fbresnet152_imagenet_pretrained</td><td>71.5 [68.7, 74.1]</td><td></td><td>54.5 [51.5, 57.4]</td><td>17.0</td></tr><tr><td>densenet161_imagenet_pretrained</td><td>71.4 [68.7, 74.1]</td><td></td><td>55.1 [52.1, 58.1]</td><td>16.3</td></tr><tr><td>densenet169_imagenet_pretrained</td><td>70.2 [67.5, 72.9]</td><td></td><td>53.1 [50.1, 56.1]</td><td>17.1</td></tr><tr><td> densenet2O1_imagenet_pretrained</td><td>70.2 [67.5, 72.9]</td><td></td><td>53.4 [50.4, 56.4]</td><td>16.8</td></tr><tr><td>dpn68_imagenet_pretrained</td><td>69.4 [66.6, 72.1]</td><td></td><td>53.3 [50.3, 56.3]</td><td>16.1</td></tr><tr><td> bninception_imagenet_pretrained</td><td>69.0 [66.2, 71.7]</td><td></td><td>49.0 [46.0, 51.9]</td><td>20.0</td></tr><tr><td>densenet121_imagenet_pretrained</td><td>69.0 [66.2, 71.7]</td><td></td><td>50.9 [47.9, 53.8]</td><td>18.1</td></tr><tr><td> nasnetamobile_imagenet_pretrained</td><td>68.8 [66.0, 71.5]</td><td></td><td>48.4 [45.4, 51.4]</td><td>20.4</td></tr><tr><td>resnet50_augment_ jpeg_compression</td><td>68.8 [66.0, 71.5]</td><td></td><td>53.2 [50.2, 56.2]</td><td>15.6</td></tr><tr><td> resnet34_imagenet_pretrained</td><td>68.0 [65.2, 70.7]</td><td></td><td>48.0 [45.0, 51.0]</td><td>20.0</td></tr><tr><td>resnet50_augment impulse_noise</td><td>67.7 [64.9, 70.5]</td><td></td><td>50.2 [47.2, 53.2]</td><td>17.5</td></tr><tr><td> resnet50_augment_gaussian_blur</td><td>67.7 [64.9, 70.5]</td><td></td><td>52.5 [49.5, 55.5]</td><td>15.2</td></tr><tr><td>resnet5O_imagenet_pretrained</td><td>67.5 [64.7, 70.3]</td><td></td><td>52.5 [49.5, 55.5]</td><td>15.0</td></tr><tr><td>resnet50_augment gaussian_noise</td><td>67.4 [64.5, 70.1]</td><td></td><td>50.6 [47.6, 53.6]</td><td>16.8</td></tr><tr><td>resnet50_augment shot_noise</td><td>66.5 [63.6, 69.2]</td><td></td><td>51.1 [48.1, 54.1]</td><td>15.4</td></tr><tr><td> vgg16_bn_imagenet_pretrained</td><td>66.4 [63.5, 69.1]</td><td></td><td>47.4 [44.5, 50.4]</td><td>19.0</td></tr><tr><td>resnet50_augment_ _defocus_blur</td><td>66.3 [63.4, 69.1]</td><td></td><td>47.6 [44.6, 50.6]</td><td>18.7</td></tr><tr><td> vgg19_bn_imagenet_pretrained</td><td>65.6 [62.7, 68.4]</td><td></td><td>46.6 [43.6, 49.6]</td><td>19.0</td></tr></table>",
+        "bbox": [
+            210,
+            426,
+            787,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/233b450930e5b6fe1110f32f8863f871995d0385f741c02ad403bde6e69521a4.jpg",
+        "table_caption": [
+            "Table 5: Classification model perturbed and original accuracies for all models in our test bed evaluated on the ImageNet-Vid-Robust dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>vgg19_imagenet_pretrained</td><td></td><td>63.2 [60.3, 66.1]</td><td></td><td>45.4 [42.4, 48.3]</td><td>17.8</td></tr><tr><td>resnet18_imagenet_pretrained</td><td></td><td>61.9 [59.0, 64.8]</td><td></td><td>41.5 [38.6, 44.4]</td><td>20.4</td></tr><tr><td>vgg13_bn_imagenet_pretrained</td><td></td><td>61.9 [59.0, 64.8]</td><td></td><td>43.3 [40.3, 46.3]</td><td>18.6</td></tr><tr><td>vgg16_imagenet_pretrained</td><td></td><td>61.4 [58.5, 64.3]</td><td></td><td>43.1 [40.2, 46.1]</td><td>18.3</td></tr><tr><td>vgg11_bn_imagenet_pretrained</td><td></td><td>60.9 [57.9, 63.8]</td><td></td><td>43.2 [40.3, 46.2]</td><td>17.7</td></tr><tr><td> vgg13_imagenet_pretrained</td><td></td><td>59.6 [56.6, 62.5]</td><td></td><td>41.1 [38.2, 44.1]</td><td>18.5</td></tr><tr><td>vgg11_imagenet_pretrained</td><td></td><td>57.3 [54.4, 60.3]</td><td></td><td>41.3 [38.4, 44.3]</td><td>16.0</td></tr><tr><td> alexnet_finetuned</td><td></td><td>57.3 [54.3, 60.2]</td><td></td><td>43.6 [40.7, 46.6]</td><td>13.7</td></tr><tr><td>ResNeXtDenoiseAll-101_robust_pgd</td><td></td><td>54.3 [51.3, 57.2]</td><td></td><td>40.8 [37.8, 43.7]</td><td>13.5</td></tr><tr><td> squeezenet1_1_imagenet_pretrained</td><td></td><td>49.8 [46.8, 52.8]</td><td></td><td>31.7 [28.9, 34.5]</td><td>18.1</td></tr><tr><td>alexnet_imagenet_pretrained</td><td></td><td>49.4 [46.4, 52.4]</td><td></td><td>32.0 [29.3, 34.8]</td><td>17.4</td></tr><tr><td>resnet50_augment contrast_change</td><td></td><td>38.3 [35.5, 41.3]</td><td></td><td>23.3 [20.8, 25.9]</td><td>15.0</td></tr></table>",
+        "bbox": [
+            210,
+            102,
+            787,
+            272
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.2 YTBB-RO B U S T ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            332,
+            325,
+            347
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/fcc419e0076f4819b8a0de121deaca86967019ef70ccea92e7f9c07fdad349e2.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Accuracy Original</td><td>Accuracy Perturbed</td><td></td><td>△</td></tr><tr><td>resnet152_finetuned</td><td></td><td>92.9 [91.2, 94.3]</td><td>84.7 [82.4, 86.8]</td><td>8.2</td></tr><tr><td>resnet50_finetuned</td><td>91.4 [89.6, 93.0]</td><td></td><td>82.0 [79.6, 84.2]</td><td>9.4</td></tr><tr><td> inceptionresnetv2_finetuned</td><td>91.3 [89.5, 92.9]</td><td></td><td>79.0 [76.4, 81.3]</td><td>12.3</td></tr><tr><td>vgg19_finetuned</td><td>90.5 [88.6, 92.2]</td><td></td><td>79.1 [76.5, 81.4]</td><td>11.4</td></tr><tr><td> vgg16_finetuned</td><td>89.1 [87.1, 90.8]</td><td></td><td>78.0 [75.4, 80.4]</td><td>11.1</td></tr><tr><td>inceptionv4_finetuned</td><td>88.5 [86.5, 90.3]</td><td></td><td>76.3 [73.6, 78.7]</td><td>12.2</td></tr><tr><td> resnet18_finetuned</td><td>88.0 [85.9, 89.8]</td><td></td><td>76.2 [73.6, 78.7]</td><td>11.8</td></tr><tr><td>alexnet_finetuned</td><td>80.6 [78.2, 82.9]</td><td></td><td>64.4 [61.5, 67.3]</td><td>16.2</td></tr><tr><td> pnasnet5large_imagenet_pretrained</td><td>65.2 [62.3, 68.0]</td><td></td><td>51.0 [48.0, 54.0]</td><td>14.2</td></tr><tr><td>nasnetalarge_imagenet_pretrained</td><td>64.9 [62.0, 67.7]</td><td></td><td>51.4 [48.4, 54.4]</td><td>13.5</td></tr><tr><td> inceptionresnetv2_imagenet_pretrained</td><td>64.5 [61.6, 67.4]</td><td></td><td> 50.4 [47.5, 53.4]</td><td>14.1</td></tr><tr><td>dpn98_imagenet_pretrained</td><td>64.1 [61.2, 66.9]</td><td></td><td>49.0 [46.0, 52.0]</td><td>15.1</td></tr><tr><td> dpn107_imagenet_pretrained</td><td>64.1 [61.2, 66.9]</td><td></td><td>50.1 [47.2, 53.1]</td><td>14.0</td></tr><tr><td>dpn131_imagenet_pretrained</td><td>64.0 [61.1, 66.8]</td><td></td><td>49.9 [46.9, 52.9]</td><td>14.1</td></tr><tr><td> inceptionv4_imagenet_pretrained</td><td>63.6 [60.7, 66.4]</td><td></td><td>48.8 [45.8, 51.8]</td><td>14.8</td></tr><tr><td>Xception_imagenet_pretrained</td><td>63.2 [60.2, 66.0]</td><td></td><td>47.6 [44.6, 50.6]</td><td>15.6</td></tr><tr><td> dpn92_imagenet_pretrained</td><td>62.3 [59.3, 65.1]</td><td></td><td>47.7 [44.8, 50.7]</td><td>14.6</td></tr><tr><td>resnet50_augment_jpeg_compressioon</td><td>62.3 [59.4, 65.2]</td><td></td><td>45.7 [42.8, 48.7]</td><td>16.6</td></tr><tr><td> polynet_imagenet_pretrained</td><td>61.4 [58.4, 64.3]</td><td></td><td>47.3 [44.4, 50.3]</td><td>14.1</td></tr><tr><td>nasnetamobile_imagenet_pretrained</td><td>61.4 [58.4, 64.3]</td><td></td><td>43.0 [40.1, 46.0]</td><td>18.4</td></tr><tr><td>resnet50_augment__shot_noise</td><td>61.3 [58.3, 64.2]</td><td></td><td>46.4 [43.4, 49.3]</td><td>14.9</td></tr><tr><td>dpn68_imagenet_pretrained</td><td>61.2 [58.3, 64.1]</td><td></td><td>44.2 [41.2, 47.2]</td><td>17.0</td></tr><tr><td> fbresnet152_imagenet_pretrained</td><td>61.1 [58.1, 64.0]</td><td></td><td>45.9 [42.9, 48.8]</td><td>15.2</td></tr><tr><td>resnet152_imagenet_pretrained</td><td>60.8 [57.8, 63.7]</td><td></td><td>46.5 [43.5, 49.5]</td><td>14.3</td></tr><tr><td> resnet101_imagenet_pretrained</td><td>60.8 [57.8, 63.7]</td><td></td><td>45.2 [42.2, 48.2]</td><td>15.6</td></tr><tr><td>senet154_imagenet_pretrained</td><td>60.7 [57.7, 63.6]</td><td></td><td>47.2 [44.3, 50.2]</td><td>13.5</td></tr><tr><td> resnet50_augment__impulse_noise</td><td>60.6 [57.7, 63.5]</td><td></td><td>45.5 [42.6, 48.5]</td><td>15.1</td></tr><tr><td> se_resnet101_imagenet_pretrained</td><td>60.5 [57.6, 63.4]</td><td></td><td>45.6 [42.6, 48.6]</td><td>14.9</td></tr><tr><td>bninception_imagenet_pretrained</td><td>60.4 [57.4, 63.3]</td><td></td><td>41.8 [38.9, 44.7]</td><td>18.6</td></tr><tr><td>densenetl61_imagenet_pretrained</td><td>60.2 [57.3, 63.1]</td><td></td><td>46.4 [43.4, 49.4]</td><td>13.8</td></tr><tr><td> resnet50_augment_gaussian_noise</td><td>60.2 [57.3, 63.1]</td><td></td><td>45.7 [42.8, 48.7]</td><td>14.5</td></tr><tr><td>se_resnext50_32x4d_imagenet_pretrained</td><td>59.9 [56.9, 62.8]</td><td></td><td>45.7 [42.7, 48.6]</td><td>14.2</td></tr><tr><td> dpn68b_imagenet_pretrained</td><td>59.7 [56.7, 62.6]</td><td></td><td>45.9 [42.9, 48.8]</td><td>13.8</td></tr><tr><td>inceptionv3_imagenet_pretrained</td><td>59.6 [56.6, 62.5]</td><td></td><td>43.8 [40.8, 46.8]</td><td>15.8</td></tr><tr><td> densenet121_imagenet_pretrained</td><td>59.5 [56.5, 62.4]</td><td></td><td>43.1 [40.1, 46.0]</td><td>16.4</td></tr><tr><td>se_resnext101_32x4d_imagenet_pretrained</td><td>59.2 [56.3, 62.1]</td><td></td><td>45.2 [42.3, 48.2]</td><td>14.0</td></tr><tr><td> densenet2O1_imagenet_pretrained</td><td>59.2 [56.2, 62.1]</td><td></td><td>44.8 [41.8, 47.8]</td><td>14.4</td></tr><tr><td>densenet169_imagenet_pretrained</td><td>59.2 [56.2, 62.1]</td><td></td><td>44.6 [41.7, 47.6]</td><td>14.6</td></tr></table>",
+        "bbox": [
+            199,
+            356,
+            795,
+            925
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/0100307e939132010e5bb841889d10d253f9256d5b95bbe9b78b3e30441116c0.jpg",
+        "table_caption": [
+            "Table 6: Classification model perturbed and original accuracies for all models in our test bed evaluated on the YTBB-robust dataset.. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td> resnet50_augment__brightness_change</td><td></td><td>58.9 [56.0, 61.8]</td><td></td><td>42.6 [39.6, 45.5]</td><td>16.3</td></tr><tr><td>se_resnet50_imagenet_pretrained</td><td></td><td>58.8 [55.9, 61.7]</td><td></td><td>44.1 [41.1, 47.1]</td><td>14.7</td></tr><tr><td> se_resnet152_imagenet_pretrained</td><td></td><td>58.8 [55.9, 61.7]</td><td></td><td>44.8 [41.9, 47.8]</td><td>14.0</td></tr><tr><td>cafferesnetlO1_imagenet_pretrained</td><td></td><td>58.2 [55.2, 61.1]</td><td></td><td>44.3 [41.3, 47.3]</td><td>13.9</td></tr><tr><td> resnet50_augment__regular</td><td></td><td>58.0 [55.1, 61.0]</td><td></td><td>42.9 [39.9, 45.8]</td><td>15.1</td></tr><tr><td>resnet34_imagenet_pretrained</td><td></td><td>57.9 [55.0, 60.9]</td><td></td><td>42.8 [39.8, 45.7]</td><td>15.1</td></tr><tr><td> vgg19_imagenet_pretrained</td><td></td><td>57.5 [54.6, 60.5]</td><td></td><td>40.1 [37.2, 43.1]</td><td>17.4</td></tr><tr><td>resnet50_augment t_gaussian_blur</td><td></td><td>57.5 [54.5, 60.4]</td><td></td><td>41.8 [38.9, 44.7]</td><td>15.7</td></tr><tr><td> vgg16_bn_imagenet_pretrained</td><td></td><td>57.2 [54.2, 60.1]</td><td></td><td>39.6 [36.7, 42.6]</td><td>17.6</td></tr><tr><td>resnet5O_imagenet_pretrained</td><td></td><td>57.0 [54.1, 60.0]</td><td></td><td>43.8 [40.9, 46.8]</td><td>13.2</td></tr><tr><td>vgg19_bn_imagenet_pretrained</td><td></td><td>56.8 [53.9, 59.8]</td><td></td><td>40.6 [37.7, 43.5]</td><td>16.2</td></tr><tr><td>vgg16_imagenet_pretrained</td><td></td><td>55.4 [52.4, 58.4]</td><td></td><td>40.1 [37.2, 43.1]</td><td>15.3</td></tr><tr><td> vgg13_bn_imagenet_pretrained</td><td></td><td>54.8 [51.8, 57.7]</td><td></td><td>38.6 [35.7, 41.6]</td><td>16.2</td></tr><tr><td>vgg11_bn_imagenet_pretrained</td><td></td><td>54.8 [51.8, 57.7]</td><td></td><td>38.8 [35.9, 41.8]</td><td>16.0</td></tr><tr><td> vgg11_imagenet_pretrained</td><td></td><td>54.7 [51.7, 57.6]</td><td></td><td>38.4 [35.5, 41.3]</td><td>16.3</td></tr><tr><td>resnetl8_imagenet_pretrained</td><td></td><td>54.4 [51.4, 57.4]</td><td></td><td>38.1 [35.2, 41.0]</td><td>16.3</td></tr><tr><td> vgg13_imagenet_pretrained</td><td></td><td>54.2 [51.3, 57.2]</td><td></td><td>37.7 [34.9, 40.7]</td><td>16.5</td></tr><tr><td>ResNeXtDenoiseAll-101_robust_pgd</td><td></td><td>53.6 [50.7, 56.6]</td><td></td><td>43.2 [40.2, 46.1]</td><td>10.4</td></tr><tr><td> squeezenet1_O_imagenet_pretrained</td><td></td><td>51.1 [48.1, 54.1]</td><td></td><td>33.1 [30.3, 36.0]</td><td>18.0</td></tr><tr><td>squeezenetl_1_imagenet_pretrained</td><td></td><td>48.6 [45.6, 51.6]</td><td></td><td>31.3 [28.6, 34.2]</td><td>17.3</td></tr><tr><td>resnet50_augment__defocus_blur</td><td></td><td>48.4 [45.4, 51.4]</td><td></td><td>29.1 [26.4, 31.8]</td><td>19.3</td></tr><tr><td>alexnet_imagenet_pretrained</td><td></td><td>45.3 [42.4, 48.3]</td><td></td><td>30.5 [27.8, 33.3]</td><td>14.8</td></tr></table>",
+        "bbox": [
+            199,
+            103,
+            797,
+            411
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C MODEL INDEPENDENT DISTRIBUTION SHIFT ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            474,
+            583,
+            491
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Though the distribution shift we induced in our study were model dependent because we found the worst neighbor frame for each model, we could study the same problem but impose a static set of perturbed frames across all models. In Figure 6 we study this static set of perturbations across all models and see a substantial (but smaller) drop in accuracy for both models. The static set of perturbations were chosen by choosing the neighbor frame that the largest number of models classified incorrectly. ",
+        "bbox": [
+            174,
+            500,
+            825,
+            584
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/f98513794c5a4b0f8364b14f6fc979d78acf7145cef44bd78021361128348e1b.jpg",
+        "image_caption": [
+            "Figure 6: Model accuracy on original vs. perturbed images for a static set of perturbed frames across all models. The grey points and grey linear fit correspond to the perturbed accuracies of models evaluated on per model perturbations studied in Figure 3 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            599,
+            759,
+            785
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D PER CLASS ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            868,
+            390,
+            885
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We study the effect of our perturbations on the 30 classes in ImageNet-Vid-Robust and YTBB-Robust to determine whether the performance drop was concentrated in a few “hard” classes. ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/6b8eca5801bdad58477c76ca5301b691cb302d1a0faade4664d14d0cc70e681e.jpg",
+        "image_caption": [
+            "Figure 7: Per-class accuracy statistics for our best performing classification model (fine-tuned ResNet152) on ImageNet-Vid-Robust and YTBB-Robust. For Youtube-BB, note that ‘zebra’ is the least common label, present in only 24 anchor frames sampled by Gu et al. (2019), of which 4 are included in our dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            307,
+            101,
+            687,
+            429
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Figure 7 shows the original and perturbed accuracies across classes for our best performing model (a fine-tuned ResNet-152). Although there are a few particularly difficult classes for perturbed accuracy (e.g., lion or monkey on ImageNet-Vid-Robust), the accuracy drop is spread across most classes. On ImageNet-Vid-Robust, this model saw a total drop of $1 4 . 4 \\%$ between original and perturbed images and a median drop of $1 4 . 0 \\%$ in per-class accuracy. On YTBB-Robust, the total drop was $8 . 9 \\%$ and the median drop was $6 . 7 \\%$ . ",
+        "bbox": [
+            173,
+            527,
+            825,
+            612
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E PER-FRAME CONDITIONAL ROBUSTNESS METRIC INTRODUCED IN GU ET AL. (2019) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            630,
+            787,
+            662
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/f195e130e1ed7f7e17d4566723b10a4c294967b869b1c196598e6b4a3fdc0427.jpg",
+        "image_caption": [
+            "Figure 8: Conditional robustness metric from Gu et al. (2019) on perturbed frames as a function of perturbation distance on ImageNet-Vid-Robust and YTBB-Robust. Model accuracies from five different model types and the best performing model are shown. The model architecture is ResNet-50 unless otherwise mentioned. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            688,
+            774,
+            851
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In concurrent work, the authors of Gu et al. (2019) considered a different metric of robustness. In this section, we compute this metric on all models in our test bed to compare our findings to $\\mathrm { G u }$ et al. (2019). There are two main differences between PM- $\\mathbf { \\nabla } \\cdot \\mathbf { k }$ and the robustness metric in Gu et al. (2019). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            145
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "1. For two visually similar “neighbor” frames $I _ { 0 }$ and $I _ { 1 }$ with true label $Y$ and classifier $f$ , Gu et al. (2019) studies the conditional probability $P ( f ( I _ { 1 } ) = y | f ( I _ { 0 } ) = y )$ 2. While PM-k looks for errors in all neighbor frames in a neighborhood of $k$ frames away from the anchor frame (so this would include frames $1 , 2 , \\ldots , \\mathbf { k }$ frames away), Gu et al. (2019) only considers errors from exactly $\\mathbf { k }$ frames away. ",
+        "bbox": [
+            210,
+            147,
+            826,
+            218
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 9 we illustrate simple example where two videos can have the same behavior for the metric introduced by Gu et al. (2019) but drastically different behavior for the PM-kmetric. ",
+        "bbox": [
+            173,
+            219,
+            821,
+            248
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/b99b31eb80549a2ce5a146b9991ebb1a16332cc9fc396d70797ec3cc6548214e.jpg",
+        "image_caption": [
+            "Figure 9: For the two example videos above the score from Gu et al. (2019) metric (Accuracy $\\ @ \\mathrm { ~ K ~ }$ ) is identical, but the PM- $\\mathbf { \\nabla } \\cdot \\mathbf { k }$ metric behaves substantially differently when the errors are spread across many independent videos, as shown in the right example "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            318,
+            262,
+            679,
+            429
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "F $\\ell _ { \\infty }$ DISTANCE VS PM-K ACCURACY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            513,
+            501,
+            531
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "$\\ell _ { \\infty }$ adversarial examples are well studied in the robustness community, yet the connection between $\\ell _ { \\infty }$ and other forms of more “natural” robustness is unclear. Here, we plot the cumulative distribution of the $\\ell _ { \\infty }$ distance between pairs of nearby frames in our datasets. In Figure 10, we show the CDF of $\\ell _ { \\infty }$ distance for all pairs, all reviewed pairs, and mistakes made by 3 indicative models. Note the fbrobust model is trained specifically to be robust to $\\ell _ { \\infty }$ adversaries. ",
+        "bbox": [
+            173,
+            541,
+            826,
+            613
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/a0fe913f4c1ab1426c7cfed965e1735fc0300673b84d41a7d2d5c94cdc30c67e.jpg",
+        "image_caption": [
+            "Figure 10: CDF showing the $\\ell _ { \\infty }$ distance between pairs of frames from different distributions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            657,
+            761,
+            877
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/dc001f6504cb8ba8ecb38ec5058a40487889afcae74aaf9decb9f0fee8c9d1c5.jpg",
+        "table_caption": [
+            "Table 7: Analyzing results based on frame-type in video compression. See Appendix H.1 for details. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Original Acc.</td><td>Perturbed Acc.</td><td>A</td><td># anchor frames</td></tr><tr><td>All frames</td><td>84.8</td><td>70.2</td><td>14.6</td><td>1109</td></tr><tr><td>w/o‘i-frames&#x27;</td><td>84.7</td><td>70.3</td><td>14.4</td><td>1104</td></tr><tr><td>w/o ‘ ‘p-frames&#x27;</td><td>83.9</td><td>73.7</td><td>10.2</td><td>415</td></tr><tr><td>w/o ‘b-frames&#x27;</td><td>85.4</td><td>73.2</td><td>12.2</td><td>699</td></tr></table>",
+        "bbox": [
+            238,
+            127,
+            758,
+            202
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "G PM-K ACCURACY WITH VARYING K ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            233,
+            509,
+            250
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "G.1 IM A G ENE T-VI D-RO B U S T ",
+        "bbox": [
+            176,
+            265,
+            405,
+            279
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/0a7c0a40f3c57359697c692f8bfed11ac08b2e1dba5ef16c54b85cea53126b9e.jpg",
+        "image_caption": [
+            "Figure 11: Model classification accuracy on perturbed frames as a function of perturbation distance (shown with $9 5 \\%$ Clopper-Pearson confidence intervals). Model accuracies from five different model types and the best performing model are shown. The model architecture is ResNet-50 unless otherwise mentioned. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            310,
+            816,
+            460
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In Figure 11, we plot the relationship between $\\mathrm { a c c } _ { \\mathrm { p m k } }$ and perturbation distance (i.e., the $\\mathrm { k }$ in the $\\mathrm { p m - k }$ metric). The entire $\\mathbf { X }$ -axis in Figure 11 corresponds to a temporal distance of at most 0.3 seconds between the original and perturbed frames. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            598
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "H I-FRAMES AND P-FRAMES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            621,
+            429,
+            637
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "H.1 IM A G ENE T-VI D-RO B U S T ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            654,
+            405,
+            666
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "One possible concern with analyzing performance on video frames is the impact of video compression on model robustness. In particular, the videos in ImageNet-Vid-Robust contain 3 different frame types: ‘i-frames’, ‘p-frames’, and ‘b-frames’. ‘p-frames’ are compressed by referencing pixel content from previous frames, while ‘b-frames’ are compressed via references to previous and future frames. ‘i-frames’ are stored without references to other frames. ",
+        "bbox": [
+            174,
+            676,
+            825,
+            746
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We compute the original and perturbed accuracies, and the drop in accuracy for a subset of the dataset without ‘i-frames’, a subset without ‘p-frames’, and a subset without ‘b-frames’ in Table 7. While there are modest differences in accuracy due to compression, this analysis suggests that the sensitivity of models is not significantly due to the differences in quality of frames due to video compression. ",
+        "bbox": [
+            174,
+            748,
+            825,
+            804
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "I FPS ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            827,
+            326,
+            843
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "I.1 IM A G ENE T-VI D-RO B U S T ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            858,
+            398,
+            872
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "To analyze the impact of frame-rate on accuracy, we show results on subsets of videos with fixed fps (25, 29, and 30, which cover $89 \\%$ of the dataset) using a fine-tuned ResNet-152 model in Table 8. The accuracy drop is similar across the subsets, and similar to the drop for the whole dataset. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/df1ada74757d9a8374160b8636806411a55fb430cfabd818bbec371f85fcc273.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 8: Results on subsets of ImageNet-Vid-Robust with fixed FPS. "
+        ],
+        "table_body": "<table><tr><td>FPS</td><td>Acc. Orig.</td><td></td><td>Acc.Perturbed</td><td>Drop</td><td># Videos</td></tr><tr><td>25</td><td>87.3 [83.0, 90.9]</td><td>73.3</td><td>[67.8, 78.3]</td><td>14.0</td><td>292</td></tr><tr><td>29</td><td>87.7 [84.0, 90.8]</td><td>74.9</td><td>[70.3, 79.2]</td><td>12.8</td><td>383</td></tr><tr><td>30</td><td>78.3 [73.3, 82.7]</td><td></td><td>61.7 [56.0, 67.1]</td><td>16.6</td><td>313</td></tr></table>",
+        "bbox": [
+            279,
+            101,
+            718,
+            161
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "J ILSVRC TRAINING WITH IM A G ENE T-VI D-RO B U S T CLASSES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            212,
+            722,
+            227
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/6f1405c47130579a96bdb5145f1fd0e06dd8b3654691a50ed8a039168841fcd2.jpg",
+        "table_caption": [
+            "We trained ResNet-50 from scratch on ILSVRC using the 30 ImageNet-Vid classes. We also finetuned the model on ImageNet-Vid. In Table 9, we show the accuracy drops are consistent with models in our submission. We hypothesize that the lower accuracy is due to coarser supervision on ILSVRC. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Acc. Orig.</td><td>Acc. Perturbed</td><td>Drop</td></tr><tr><td>ILSVRC-30</td><td>61.0</td><td>44.9</td><td>15.1</td></tr><tr><td>ILSVRC-30 + FT</td><td>77.8</td><td>59.9</td><td>17.9</td></tr></table>",
+        "bbox": [
+            297,
+            291,
+            699,
+            338
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Table 9: Results of training ResNet-50 on ILSVRC with 30 classes from ImageNet-Vid-Robust. ",
+        "bbox": [
+            171,
+            348,
+            821,
+            363
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "K EXPERIMENTAL DETAILS & HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            390,
+            617,
+            407
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "All classification experiments were carried out using PyTorch version 1.0.1 on an AWS p3.2xlarge with the NVIDIA V100 GPU. All pretrained models were downloaded from Cadene at commit hash $0 2 1 \\mathtt { d } 9 7 8 9 7 \\mathtt { c } 9 \\mathtt { a } \\mathtt { a } 7 6 \\mathtt { e } \\mathtt { c } 7 5 9 \\mathtt { d } \\mathtt { e } \\mathtt { f } \\mathtt { f } 4 3 \\mathtt { d } 3 4 1 \\mathtt { c } 4 \\mathtt { f } \\mathtt { d } 4 5 \\mathtt { d } 7 \\mathtt { b } \\mathtt { a } .$ Evaluations in Table ?? all use the default settings for evaluation. The hyperparameters for the fine-tuned models are presented in Table 10. We searched for learning rates between $1 0 ^ { - 3 }$ and $1 0 ^ { - 5 }$ for all models. ",
+        "bbox": [
+            174,
+            416,
+            825,
+            486
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We additionally detail hyperparameters for detection models in Table 11. Detection experiments were conducted with PyTorch version 1.0.1 on a machine with 4 Titan X GPUs, using the Mask R-CNN benchmark repositoryMassa and Girshick (2018). We used the default learning rate provided in Massa and Girshick (2018). For R-FCN, we used the model trained by Xiao and Jae Lee (2018). ",
+        "bbox": [
+            174,
+            488,
+            825,
+            544
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/d5a74fae0e642c9647b2d644d60c1477a4ef3db4fbd4fb4933b7714e8634f583.jpg",
+        "table_caption": [
+            "Table 10: Hyperparameters for models finetuned on ImageNet-Vid, ",
+            "Table 11: Hyperparameters for detection models. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Base Learning Rate</td><td>Learning Rate Schedule</td><td></td><td>Batch Size</td><td>Epochs</td></tr><tr><td>resnet152</td><td>10-4</td><td>Reduce</td><td>LR On Plateau</td><td>32</td><td>10</td></tr><tr><td>resnet50</td><td>10-4</td><td>Reduce</td><td>LR On Plateau</td><td>32</td><td>10</td></tr><tr><td> alexnet</td><td>10-5</td><td>Reduce </td><td> LR On Plateau</td><td>32</td><td>10</td></tr><tr><td>vgg16</td><td>10-5</td><td>Reduce</td><td> LR On Plateau</td><td>32</td><td>10</td></tr></table>",
+        "bbox": [
+            197,
+            582,
+            795,
+            665
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/359953d2de2dd32d994d690a7ad4e4b7f0c5fe173cde7f6ee3b4a2a35bd7e689.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Base Learning Rate</td><td>Learning Rate Schedule</td><td>Batch Size</td><td>Iterations</td></tr><tr><td>F-RCNN ResNet-50</td><td>10-2</td><td>Step 20k，30k</td><td>8</td><td>40k</td></tr><tr><td>F-RCNN ResNet-101</td><td>10-2</td><td>Step 20k，30k</td><td>8</td><td>40k</td></tr></table>",
+        "bbox": [
+            173,
+            695,
+            820,
+            750
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "L DETECTION PM-K ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            755,
+            356,
+            770
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We briefly introduce the mAP metric for detection here and refer the reader to Lin et al. for further details. The standard detection metric proceeds by first determining whether each predicted bounding box in an image is a true or false positive, based on the intersection over union (IoU) of the predicted and ground truth bounding boxes. The metric then computes the per-category average precision (AP, averaged over recall thresholds) of the predictions across all images. The final metric is reported as the mean of these per-category APs (mAP). ",
+        "bbox": [
+            173,
+            780,
+            825,
+            863
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We define the $\\mathrm { p m - k }$ analog of mAP by replacing each anchor frame in the dataset with a nearby frame that minimizes the per-image average precision. Since the category-specific average precision is undefined for categories not present in an image, we minimize the average precision across categories present in each frame rather than the mAP. ",
+        "bbox": [
+            174,
+            866,
+            823,
+            921
+        ],
+        "page_idx": 16
+    }
+]

parse/train/hsFN92eQEla/hsFN92eQEla.md

@@ -0,0 +1,360 @@
+# EVALUATION OF NEURAL ARCHITECTURES TRAINED WITH SQUARE LOSS VS CROSS-ENTROPY IN CLASSIFICATION TASKS
+
+Like Hui   
+Computer Science and Engineering   
+University of California, San Diego   
+San Diego, CA 92093   
+lhui@ucsd.edu   
+Mikhail Belkin   
+Halıcıoglu Data Science Institute ˘   
+University of California, San Diego   
+San Diego, CA 92093   
+mbelkin@ucsd.edu
+
+# ABSTRACT
+
+Modern neural architectures for classification tasks are trained using the crossentropy loss, which is widely believed to be empirically superior to the square loss. In this work we provide evidence indicating that this belief may not be wellfounded. We explore several major neural architectures and a range of standard benchmark datasets for NLP, automatic speech recognition (ASR) and computer vision tasks to show that these architectures, with the same hyper-parameter settings as reported in the literature, perform comparably or better when trained with the square loss, even after equalizing computational resources. Indeed, we observe that the square loss produces better results in the dominant majority of NLP and ASR experiments. Cross-entropy appears to have a slight edge on computer vision tasks.
+
+We argue that there is little compelling empirical or theoretical evidence indicating a clear-cut advantage to the cross-entropy loss. Indeed, in our experiments, performance on nearly all non-vision tasks can be improved, sometimes significantly, by switching to the square loss. Furthermore, training with square loss appears to be less sensitive to the randomness in initialization. We posit that training using the square loss for classification needs to be a part of best practices of modern deep learning on equal footing with cross-entropy.
+
+# 1 INTRODUCTION
+
+Modern deep neural networks are nearly universally trained with cross-entropy loss in classification tasks. To illustrate, cross-entropy is the only loss function specifically discussed in connection with training neural networks for classification in popular references (Goodfellow et al., 2016; Zhang et al., 2020). It is the default for classification in widely used packages such as NLP implementation Hugging Face Transformers (Wolf et al., 2019), speech classification by ESPnet (Watanabe et al., 2018) and image classification implemented by torchvision (Marcel & Rodriguez, 2010). Yet we know of few empirical evaluations or compelling theoretical analyses to justify the predominance of cross-entropy in practice. In what follows, we use a number of modern deep learning architectures and standard datasets across the range of tasks of natural language processing, speech recognition and computer vision domains as a basis for a systematic comparison between the cross-entropy and square losses. The square loss (also known as the Brier score (Brier, 1950) in the classification context) is a particularly useful basis for comparison since it is nearly universally used for regression tasks and is available in all major software packages. To ensure a fair evaluation, for the square loss we use hyper-parameter settings and architectures exactly as reported in the literature for crossentropy, with the exception of the learning rate, which needs to be increased in comparison with cross-entropy and, for problems with a large number of classes (42 or more in our experiments), loss function rescaling (see Section 5).
+
+Our evaluation includes 20 separate learning tasks1 (neural model/dataset combinations) evaluated in terms of the error rate or, equivalently, accuracy (depending on the prevalent domain conventions). We also provide some additional domain-specific evaluation metrics – F1 for NLP tasks, and Top-5 accuracy for ImageNet. Training with the square loss provides accuracy better or equal to that of cross-entropy in 17 out of 20 tasks. These results are for averages over multiple random initalizations, results for each individual initialization are similar. Furthermore, we find that training with the square loss has smaller variance with respect to the randomness of the initialization in the majority of our experiments.
+
+Our results indicate that the models trained using the square loss are not just competitive with same models trained with cross-entropy across nearly all tasks and settings but, indeed, provide better classification results in the majority of our experiments. The performance advantage persists even when we equalize the amount of computation by choosing the number of epochs for training the square loss to be the same as the optimal (based on validation) number of epochs for cross-entropy, a setting favorable to cross-entropy.
+
+Note that with the exception of the learning rate, we utilized hyper-parameters reported in the literature, originally optimized for the cross-entropy loss. This suggests that further improvements in performance for the square loss can potentially be obtained by hyper-parameter tuning.
+
+Based on our results, we believe that the performance of modern architectures on a range of classification tasks may be improved by using the square loss in training. We conclude that the choice between the cross-entropy and the square loss for training needs to be an important aspect of model selection, in addition to the standard considerations of optimization methods and hyper-parameter tuning.
+
+A historical note. The modern ubiquity of cross-entropy loss is reminiscent of the predominance of the hinge loss in the era of the Support Vector Machines (SVM). At the time, the prevailing intuition had been that the hinge loss was preferable to the square loss for training classifiers. Yet, the empirical evidence had been decidedly mixed. In his remarkable thesis (Rifkin, 2002), Ryan Rifkin conducted an extensive empirical evaluation and concluded that “the performance of the RLSC [square loss] is essentially equivalent to that of the SVM [hinge loss] across a wide range of problems, and the choice between the two should be based on computational tractability considerations”. More recently, the experimental results in (Que & Belkin, 2016) show an advantage to training with the square loss over the hinge loss across the majority of the tasks, paralleling our results in this paper. We note that conceptual or historical reasons for the current prevalence of cross-entropy in training neural networks are not entirely clear.
+
+Theoretical considerations. The accepted justification of cross-entropy and hinge loss for classification is that they are better “surrogates” for the 0-1 classification loss than the square loss, e.g. (Goodfellow et al., 2016), Section 8.1.2. There is little theoretical analysis supporting this point of view. To the contrary, the recent work (Muthukumar et al., 2020) proves that in certain overparameterized regimes, the classifiers obtained by minimizing the hinge loss and the square loss in fact the same. While the hinge loss is different from cross-entropy, these losses are closely related in certain settings (Ji & Telgarsky, 2019; Soudry et al., 2018). See (Muthukumar et al., 2020) for a more in-depth theoretical discussion of loss functions and the related literature.
+
+Probability interpretation of neural network output and calibration. An argument for using the cross-entropy loss function is sometimes based on the idea that networks trained with crossentropy are able to output probability of a new data point belonging to a given class. For linear models in the classical analysis of logistic regression, minimizing cross-entropy (logistic loss) indeed yields the maximum likelihood estimator for the model (e.g.,(Harrell Jr, 2015), Section 10.5). Yet, the relevance of that analysis to modern highly non-linear and often over-parameterized neural networks is questionable. For example, in (Gal & Ghahramani, 2016) the authors state that $^ { * } I n$ classification, predictive probabilities obtained at the end of the pipeline (the softmax output) are often erroneously interpreted as model confidence”. Similarly, the work (Xing et al., 2019) asserts that “for DNNs with conventional (also referred as ‘vanilla’) training to minimize the softmax crossentropy loss, the outputs do not contain sufficient information for well-calibrated confidence estimation”. Thus, accurate class probability estimation cannot be considered an unambiguous advantage of neural networks trained with cross-entropy. While the analysis of calibration for different loss functions is beyond the scope of this paper, we note that in many practical settings accurate classification, the primary evaluation metric of this work, takes precedence over the probability estimation.
+
+Domain applicability. It is interesting to note that in our experiments the square loss generally performs better on NLP and ASR tasks, while cross-entropy has a slight edge on computer vision. It is tempting to infer that the square loss is suitable for NLP and speech, while cross-entropy may be more appropriate for training vision architectures. Yet we are wary of over-interpreting the evidence. In particular, we observe that the cross-entropy has a significant performance advantage on just a single vision architecture (EfficientNet (Tan & Le, 2019) trained on ImageNet). The rest of the vision results are quite similar between square loss and cross-entropy and are likely to be sensitive to the specifics of optimization and parameter tuning. Understanding whether specific loss functions are better suited for certain domain will require more in-depth experimental work.
+
+Related work. The choice of a loss function is an integral and essential aspect of training neural networks. Yet we are aware of few comparative analyses of loss functions and no other systematic studies of modern architectures across a range of datasets. Kline & Berardi (2005) compared the effectiveness of squared-error versus cross-entropy in estimating posterior probabilities with small neural networks, five or less nodes in each layer, and argued that cross-entropy had a performance advantage. Golik et al. (2013) provided a comparison of cross-entropy and squared error training for a hybrid HMM/neural net model for one ASR and one handwriting recognition datasets. The authors observed that with a good initialization by pre-training, training with the squared error had better performance than the cross-entropy. Sangari & Sethares (2015) analyzed the convergence of mean squared error (MSE) and cross-entropy under the normalized logistic regression model (Soft-Max) setting, and indicated the MSE loss function is robust to the true model parameter values and can converge to the same parameter estimation variance of the cross-entropy loss function with half the number of gradient descent iterations. Janocha & Czarnecki (2017) compared several different loss functions on MNIST and CIFAR-10 datasets concluding that “depending on the application of the deep model – losses other than log loss [cross-entropy] are preferable”. A recent work (Demirkaya et al., 2020) provided a theoretical comparison of square and cross-entropy losses for training mixture models. The authors argued that the cross-entropy loss has more favorable optimization landscapes in multiclass settings. To alleviate that issue, they proposed rescaling of the loss function equivalent to choosing parameter $k$ in Section 5. The authors showed that rescaling allowed the square loss to become competitive with cross-entropy on CIFAR-100, a finding that aligns with the results in our paper.
+
+# 2 EXPERIMENTS
+
+We conducted experiments on a number of benchmark datasets for NLP, ASR and computer vision, following the standard recipes given in recent papers of each domain. Four NLP datasets are MRPC, SST-2, QNLI and QQP. TIMIT, WSJ and Librispeech are three standard datasets used for training ASR systems. For vision experiments, we choose MNIST, CIFAR-10, and ImageNet. To the best of our knowledge, we are the first to experimentally compare the square loss and the cross-entropy on a wide range of datasets with different size, dimensionality (number of features) and the number of classes (up to 1000 class numbers). See Appendix A for references and description.
+
+Architectures. In what follows we explore several widely used modern neural architectures. For NLP tasks, we implement classifiers with a fine-tuned BERT (Devlin et al., 2018), a LSTM+Attention model (Chen et al., 2017), and a LSTM $^ +$ CNN model (He & Lin, 2016). Joint CTC-Attention based model (Kim et al., 2017), triggered attention model with VGG and BLSTM modules (Moritz et al., 2019) are used for ASR tasks. Note that for the CTC-Attention based model, the original loss function is a weighted sum of the cross-entropy and the CTC loss. When training with the square loss, we only replace the cross-entropy to be the square loss, and keep the CTC loss untouched. For vision tasks, we use TCNN (Bai et al., 2018), Wide ResNet (Zagoruyko & Komodakis, 2016), ResNet (He et al., 2016) and EfficientNet (Tan & Le, 2019) architectures.
+
+Experimental protocols. For training with the cross-entropy loss, we use a standard protocol, which is to stop training after the validation accuracy does not improve for five consecutive epochs. For the square loss we use two protocols. The first one is the same as for cross-entropy. The second protocol is to train the square loss using the number of epochs selected when training the cross-entropy loss with the first protocol. The second protocol is designed to equalize the usage of computational resources between the square loss and cross-entropy and is favorable to cross-entropy.
+
+Following the hyper-parameter settings of the architectures in the literature, we re-implement the models trained with the cross-entropy loss keeping the same architecture and hyper-parameter settings. We train the same models using the square loss, employing our two experimental protocols. The only alteration to the parameters of the network reported in the literature is adjustment of the learning rate. For datasets with a large number of labels (42 or more in our experiments) we apply loss function rescaling (see Section 5).
+
+The key points for the implementation are described in Section 5. The implementation details and specific hyper-parameter settings are given in Appendix B. See Appendix D for a summary of comparisons between the original results and our re-implementations. Additionally, we report the results on validation sets and training sets in Appendix C.
+
+The results presented below are average results of 5 runs corresponding to 5 different random initalizations for each task. The result across initializations are given in Section 3.
+
+# 2.1 NLP EXPERIMENTS
+
+We conduct 2-class classification tasks from NLP domain. The datasets information is summarized in Table 1. As in (Wang et al., 2018), we report accuracy and F1 scores for MRPC and QQP datasets, and report accuracy for SST-2 and QNLI.
+
+Table 1: NLP task statistics and descriptions   
+
+<table><tr><td>Corpus</td><td>Train</td><td>[Test</td><td>#classes</td><td>Metric</td><td>Domain</td></tr><tr><td>MRPC (Dolan &amp; Brockett, 2005)</td><td>3.7K</td><td>1.7K</td><td>2</td><td>acc./F1</td><td>news</td></tr><tr><td>SST-2 (Socher et al., 2013)</td><td>67K</td><td>1.8K</td><td></td><td>acc.</td><td>movie reviews</td></tr><tr><td>QNLI (Rajpurkar et al., 2016)</td><td>105K</td><td>5.4K</td><td></td><td>acc.</td><td>Wikipedia</td></tr><tr><td>QQP (Iyer et al., 2017)</td><td>364K</td><td>391K</td><td>２２2</td><td>acc./F1</td><td>social QA questions</td></tr></table>
+
+Table 2 gives the accuracy and Table 3 gives the F1 scores of the neural models on NLP tasks. As can be seen in Table 2, in 9 out of 10 tasks using the square loss has better/equal accuracy compared with using the cross-entropy, and in terms of F1 score (see Table 3), 5 out of 6 tasks training with the square loss outperform training with the cross-entropy loss. Even with same epochs, i.e. with same computation cost, using the square loss has equal/better accuracy in 8 out of 10 tasks , and has higher F1 score in 5 out of 6 tasks.
+
+Table 2: NLP results, accuracy   
+
+<table><tr><td>Model</td><td>Task</td><td>train with square loss (%)</td><td>train with cross-entropy (%)</td><td>square loss w/ same epochs as CE (%)</td></tr><tr><td rowspan="4">BERT (Devlin et al., 2018)</td><td>MRPC</td><td>83.8</td><td>82.1</td><td>83.6</td></tr><tr><td>SST-2</td><td>94.0</td><td>93.9</td><td>93.9</td></tr><tr><td>QNLI</td><td>90.6</td><td>90.6</td><td>90.6</td></tr><tr><td>QQP</td><td>88.9</td><td>88.9</td><td>88.8</td></tr><tr><td rowspan="3">LSTM+Attention (Chen et al., 2017)</td><td>MRPC</td><td>71.7</td><td>70.9</td><td>71.5</td></tr><tr><td>QNLI</td><td>79.3</td><td>79.0</td><td>79.3</td></tr><tr><td>QQP</td><td>83.4</td><td>83.1</td><td>83.4</td></tr><tr><td rowspan="3">LSTM+CNN (He &amp; Lin,2016)</td><td>MRPC</td><td>73.2</td><td>69.4</td><td>72.5</td></tr><tr><td>QNLI</td><td>76.0</td><td>76.0</td><td>76.0</td></tr><tr><td>QQP</td><td>84.3</td><td>84.4</td><td>84.3</td></tr></table>
+
+Table 3: NLP results, F1 scores   
+
+<table><tr><td>Model</td><td>Task</td><td>train with square loss (%)</td><td>train with cross-entropy (%)</td><td>square loss w/ same epochs as CE (%)</td></tr><tr><td>BERT</td><td>MRPC</td><td>88.1</td><td>86.7</td><td>88.0</td></tr><tr><td>(Devlin et al., 2018)</td><td>QQP</td><td>70.9</td><td>70.7</td><td>70.7</td></tr><tr><td>LSTM+Attention</td><td>MRPC</td><td>80.9</td><td>80.6</td><td>80.7</td></tr><tr><td>(Chen et al.,2017)</td><td>QQP</td><td>62.6</td><td>62.3</td><td>62.6</td></tr><tr><td>LSTM+CNN</td><td>MRPC</td><td>81.0</td><td>78.2</td><td>81.0</td></tr><tr><td>(He &amp; Lin,2016)</td><td>QQP</td><td>60.3</td><td>60.5</td><td>60.3</td></tr></table>
+
+We observe the relative improvements brought by training with the square loss vary with different model architectures, and other than LSTM $\cdot +$ CNN model on QQP dataset, all architectures trained with the square loss have better/equal accuracy and F1 score. The performance of loss functions also varies with data size, especially for MRPC, which is a relatively small dataset, all model architectures trained with the square loss gives significantly better results than the cross-entropy.
+
+# 2.2 AUTOMATIC SPEECH RECOGNITION (ASR) EXPERIMENTS
+
+We consider three datasets, TIMIT, WSJ and Librispeech, and all are ASR tasks. For Librispeech, we choose its train-clean-100 as training set, dev-clean and test-clean as validation and test set. We report phone error rate (PER) and character error rate (CER) for TIMIT, word error rate (WER) and CER for both WSJ and Librispeech. A brief description of the datasets used in our ASR experiments is given in Table $4 ^ { 2 }$ . Note that we only alter the training loss of the acoustic model, while keeping the language model and decoding part the same as described in the literature. The acoustic model is a classifier with the dictionary size as the class number. For TIMIT, getting PER and CER needs two different acoustic models, i.e. they are two separate classification tasks, 42-class classification for PER, and 27-class classification for CER. For WSJ, the size of dictionary used for acoustic model is 52. WER and CER of WSJ are calculated with one acoustic model. Hence for WSJ it is a 52-class classification task for both WER and CER. Acoustic model of Librispeech is a 1000-class classifier for both WER and CER, as we use 1000 unigram (Jurafsky, 2000) based dictionary. The results are in Table 5.
+
+Table 4: ASR task statistics and descriptions   
+
+<table><tr><td>Corpus</td><td>Train</td><td>Test</td><td>#classes</td><td>Metric</td><td>Domain</td></tr><tr><td>TIMIT (Garofolo et al., 1993)</td><td>1.15M</td><td>54K</td><td>42 27</td><td>PER CER</td><td>3.2 hours (training set) telephone English</td></tr><tr><td>WSJ (Paul &amp; Baker,1992)</td><td>28.8M</td><td>252K</td><td>52*</td><td>WER CER</td><td>80 hours (training set) read newspapers</td></tr><tr><td>Librispeech (Panayotov et al., 2015)</td><td>36M</td><td>1M</td><td>1000*</td><td>WER CER</td><td>100 hours (training set) audio books</td></tr></table>
+
+\* This is the number of classes used for training the acoustic model.
+
+Table 5: ASR results, error rate   
+
+<table><tr><td>Model</td><td>Task</td><td>trainwith square loss (%)</td><td>trainwith cross-entropy (%)</td><td>square loss w/ same epochs as CE (%)</td></tr><tr><td>Attention+CTC</td><td>TIMIT (PER)</td><td>20.8</td><td>20.8</td><td>20.8</td></tr><tr><td>(Kim et al., 2017)</td><td>TIMIT (CER)</td><td>32.5</td><td>33.4</td><td>32.5</td></tr><tr><td>VGG+BLSTMP</td><td>WSJ (WER)</td><td>5.1</td><td>5.3</td><td>5.1</td></tr><tr><td>(Moritz et al., 2019)</td><td>WSJ (CER)</td><td>2.4</td><td>2.5</td><td>2.4</td></tr><tr><td>VGG+BLSTM</td><td>Librispeech (WER)</td><td>9.8</td><td>10.6</td><td>10.3</td></tr><tr><td>(Moritz et al.,2019)</td><td>Librispeech (CER)</td><td>9.7</td><td>10.7</td><td>10.2</td></tr></table>
+
+We see that the square loss performs better (equal for TIMIT PER result) in all of our tasks. It is interesting to observe that the performance advantage of the square loss reported in Table 5 increases with dataset size. In particular, the relative advantage of the square loss $9 . 3 \%$ relative improvement on CER, and $7 . 5 \%$ on WER, respectively) is largest for the biggest dataset, Librispeech. On WSJ, using the square loss has ${ \sim } 4 \%$ relative improvement on both CER and WER, while the results on TIMIT for the square loss and cross-entropy are very similar. The question of whether this dependence between the data size and the relative advantage of the square loss over cross-entropy is a coincidence or a recurring pattern requires further investigation.
+
+For TIMIT and WSJ, we observed that training with both the square loss and the cross-entropy need same epochs to converge. The two training protocols for training with the square loss have same performance, and both are comparable/better than training with the cross-entropy. On Librispeech, the square loss needs more epochs, but provides better performance.
+
+# 2.3 COMPUTER VISION EXPERIMENTS
+
+For vision tasks we conduct experiments on MNIST, CIFAR-10 and ImageNet, as in Table 6.
+
+Table 6: Vision task statistics and descriptions   
+
+<table><tr><td>Corpus</td><td>Train</td><td>[Test</td><td>#classes</td><td>Metric</td><td>Domain</td></tr><tr><td>MNIST (LeCun et al., 1998)</td><td>60K</td><td>10K</td><td>10</td><td>acc.</td><td>28×28</td></tr><tr><td>CIFAR-10 (Krizhevsky&amp; Hinton,2009)</td><td>50K</td><td>10K</td><td>10</td><td>acc.</td><td>32 ×32</td></tr><tr><td>ImageNet (Russakovsky et al., 2015)</td><td>~1.28M</td><td>50K3</td><td>1000</td><td>acc. Top-5 acc.</td><td>224 × 224</td></tr></table>
+
+As in Table 7, on MNIST and CIFAR-10, training with the square loss and the cross-entropy have comparable accuracy. On much larger ImageNet, with ResNet-50 architecture, the accuracy and Top-5 accuracy of using the square loss are comparable with the ones got by using the cross-entropy loss. While with EfficientNet, using the cross-entropy shows better results. The performance of different loss functions varies among different architectures. On MNIST and CIFAR-10, we use exactly the same hyper-parameters well-selected for the cross-entropy loss. For ImageNet, we adjust the learning rate and add a simple rescaling scheme (see Section 5), all other hyper-parameters are the same as for the cross-entropy loss. The performance of using the square loss can improve with more hyper-parameter tuning.
+
+Table 7: Vision results, accuracy   
+
+<table><tr><td>Model</td><td>Task</td><td>train with square loss (%)</td><td>train with cross-entropy (%)</td><td>square loss w/ same epochs as CE(%)</td></tr><tr><td>TCNN (Bai et al.,2018)</td><td>MNIST(acc.)</td><td>97.7</td><td>97.7</td><td>97.7</td></tr><tr><td>W-Resnet (Zagoruyko &amp; Komodakis,2016)</td><td>CIFAR-10 (acc.)</td><td>95.9</td><td>96.3</td><td>95.9</td></tr><tr><td>ResNet-50</td><td>ImageNet (acc.)</td><td>76.2</td><td>76.1</td><td>76.0</td></tr><tr><td>(He et al.,2016)</td><td>ImageNet(Top-5 acc.)</td><td>93.0</td><td>93.0</td><td>92.9</td></tr><tr><td>EfficientNet</td><td>ImageNet (acc.)</td><td>74.6</td><td>77.0</td><td>74.6</td></tr><tr><td>(Tan&amp;Le,2019)</td><td>ImageNet(Top-5 acc.)</td><td>92.7</td><td>93.3</td><td>92.7</td></tr></table>
+
+For all three datasets, training with the square loss converges as fast as training with the crossentropy, and our two experimental protocols for the square loss result in same accuracy performance (except ImageNet with ResNet-50 model).
+
+# 3 PERFORMANCE ACROSS DIFFERENT INITIALIZATIONS
+
+![](images/fd41992afa5473ae7d64be9e560f1759fd79b1f6d3a44b9571dccc7334757a2e.jpg)  
+Figure 1: Difference between accuracy (or error rate) between square loss and CE for each initialization. (Square loss acc. - CE acc.) is shown for accuracy, (CE - Square loss) for error rate.
+
+To evaluate the stability of the results with respect to the randomness of model initialization we analyze the results for each random seed initialization. For each random seed, we calculate the difference between the the accuracy (or the error) of networks trained with the square loss and the cross-entropy respectively. We present the results with error bars for one standard deviation in Figure 1. Absolute error and accuracy results for each run and the corresponding standard deviations are given in Appendix F.
+
+Table 8 (Libri is short for Librispeech and I-Net is short for ImageNet) shows the standard deviation of test accuracy/error for training with the square loss and cross-entropy. Square loss has smaller variance in 15 out of 20 tasks, which indicates that training with the square loss is less sensitive to the randomness in the training process.
+
+# 4 OBSERVATIONS DURING TRAINING
+
+Table 8: Standard deviation of test accuracy/error. Smaller number is bolded.   
+
+<table><tr><td>Model</td><td>Dataset</td><td>Square loss</td><td>CE</td></tr><tr><td rowspan="4">BERT</td><td>MRPC</td><td>0.484</td><td>0.766</td></tr><tr><td>SST-2</td><td>0.279</td><td>0.173</td></tr><tr><td>QNLI</td><td>0.241</td><td>0.205</td></tr><tr><td>QQP</td><td>0.045</td><td>0.063</td></tr><tr><td rowspan="3">LSTM +Attention</td><td>MRPC</td><td>0.484</td><td>0.786</td></tr><tr><td>QNLI</td><td>0.210</td><td>0.371</td></tr><tr><td>QQP</td><td>0.566</td><td>0.352</td></tr><tr><td rowspan="3">LSTM +CNN</td><td>MRPC</td><td>0.322</td><td>0.383</td></tr><tr><td>QNLI</td><td>0.173</td><td>0.286</td></tr><tr><td>QQP</td><td>0.458</td><td>0.161</td></tr><tr><td rowspan="2">Attention +CTC</td><td>TIMIT (PER)</td><td>0.508</td><td>0.249</td></tr><tr><td>TIMIT (CER)</td><td>0.361</td><td>0.873</td></tr><tr><td>VGG+</td><td>WSJ (WER)</td><td>0.184</td><td>0.249</td></tr><tr><td>BLSTMP</td><td>WSJ (CER)</td><td>0.077</td><td>0.118</td></tr><tr><td>VGG+</td><td>Libri (WER)</td><td>0.126</td><td>0.257</td></tr><tr><td>BLSTM</td><td>Libri (CER)</td><td>0.148</td><td>0.316</td></tr><tr><td>TCNN</td><td>MNIST</td><td>0.161</td><td>0.173</td></tr><tr><td>W-ResNet</td><td>CIFAR-10</td><td>0.184</td><td>0.481</td></tr><tr><td rowspan="2">ResNet-50</td><td>I-Net (Top-1)</td><td>0.032</td><td>0.045</td></tr><tr><td>I-Net (Top-5)</td><td>0.126</td><td>0.045</td></tr><tr><td rowspan="2">EfficientNet</td><td>I-Net (Top-1)</td><td>0.138</td><td>0.122</td></tr><tr><td>I-Net (Top-5)</td><td>0.089</td><td>0.089</td></tr></table>
+
+There are several interesting observations in terms of   
+the optimization speed comparing training with the square loss and the cross-entropy loss. We give the experimental observations for the cases when the class number is small, as for our NLP tasks, which are all 2-class classification tasks, and when the class number is relatively large, as for Libripseech and ImageNet (both have 1000 classes).
+
+![](images/88dedb56f24a859ae4a14e6a8b164e5fe8f3ac71a967026d82629db2d3e1eaf8.jpg)  
+Figure 2: Training curves
+
+We compare the convergence speed in terms of accuracy, and find that for 2-class NLP classification tasks, the training curves of training with the square loss and the cross-entropy are quite similar. Figure 2 (a) gives the accuracy of three model architectures trained with the square loss and the crossentropy along different epochs for QNLI dataset. For all three models, BERT, LSTM $+$ Attention, and LSTM+CNN, using the square loss converges as fast as cross-entropy loss, and achieves better/comparable accuracy to training with the cross-entropy.
+
+Convergence speed when class number is large When the class number becomes large, as on speech dataset Librispeech and vision dataset ImageNet, training with the square loss may need more epochs to converge. Figure 2 (b) gives the classification accuracy of acoustic model along different epochs, and Figure 2 (c) gives the accuracy (Top-1) and Top-5 accuracy along different training steps of ResNet on ImageNet. Training with the square loss converges slower but reaches similar/better accuracy.
+
+# 5 IMPLEMENTATION
+
+We summarize the key points of implementation in this section. Full details and the exact parameters are given in Appendix B. Two important pieces of the implementation are (1) no softmax for training with the square loss and (2) loss rescaling for datasets with large number of classes.
+
+No softmax. The widely accepted pipeline for modern neural classification tasks trained with the crossentropy loss contains the last softmax layer before calculating the loss. When training with the square loss that layer needs to be removed as it appears to impede optimization.
+
+Loss rescaling mechanism. For datasets with a small number of classes, we do not use any additional mechanisms. For datasets with a large number of output classes $\geq 4 2$ in our experiments) we employ loss rescaling which helps to accelerate training. Let $( { \pmb x } , { \pmb y } )$ denote a single labeled point, where $\pmb { x } \in \mathbb { R } ^ { d }$ is the feature vector, and $\boldsymbol { y } \in \mathbb { R } ^ { C }$ . Here $C$ is the number
+
+Table 9: Rescaling parameters   
+
+<table><tr><td>Dataset</td><td>#classes</td><td>k</td><td>M</td></tr><tr><td>MRPC</td><td>2</td><td>1</td><td>1</td></tr><tr><td>SST-2</td><td>2</td><td>1</td><td>1</td></tr><tr><td>QNLI</td><td>2</td><td>1</td><td>1</td></tr><tr><td>QQP</td><td>2</td><td>1</td><td>1</td></tr><tr><td>TIMIT (CER)</td><td>27</td><td>1</td><td>1</td></tr><tr><td>TIMIT (WER)</td><td>42</td><td>1</td><td>15</td></tr><tr><td>WSJ</td><td>52</td><td>1</td><td>15</td></tr><tr><td>Librispeech</td><td>1000</td><td>15</td><td>30</td></tr><tr><td>MNIST</td><td>10</td><td></td><td></td></tr><tr><td>CIFAR-10</td><td></td><td>1</td><td>1</td></tr><tr><td>ImageNet</td><td>10 1000</td><td>1 15</td><td>1 30</td></tr></table>
+
+of output labels and $\pmb { y } = [ 0 , \ldots , \underbrace { 1 } _ { } , 0 , \ldots , 0 ]$ is the corresponding one-hot encoding vector of the {zc   
+label $c$ . We denote our model by $f : \mathbb { R } ^ { d }  \mathbb { R } ^ { C }$ .
+
+The standard square loss for the one-hot encoded label vector can be written (at a single point) as
+
+$$
+l = \frac { 1 } { C } \left( ( f _ { c } ( \pmb { x } ) - 1 ) ^ { 2 } + \sum _ { i = 1 , i \neq c } ^ { C } f _ { i } ( \pmb { x } ) ^ { 2 } \right)
+$$
+
+For a large number of classes, we use the rescaled square loss defined by two parameters, $k$ and $M$ , as follows:
+
+$$
+l _ { s } = \frac { 1 } { C } \left( k * ( f _ { c } ( \pmb { x } ) - M ) ^ { 2 } + \sum _ { i = 1 , i \neq c } ^ { C } f _ { i } ( \pmb { x } ) ^ { 2 } \right) .
+$$
+
+The parameter $k$ rescales the loss value at the true label, while $M$ rescales the one-hot encoding (the one-hot vector is multiplied by $M$ ). Note that when $k = M = 1$ , the rescaled square loss is same as the standard square loss in Eq. 1. The values of $k$ and $M$ for all experiments are given in Table 9. As in (Demirkaya et al., 2020), the parameter $k$ is used to increase the emphasis on the correct class in multiclass classification, and this paper proves how adding $k$ can simplify the optimization landscape. We find that for very large class numbers additional parameter $M$ further improves performance.
+
+# 6 SUMMARY AND DISCUSSION
+
+In this work we provided an empirical comparison of training with the cross-entropy and square loss functions for classification tasks in a range of datasets and architectures. We observe that the square loss outperforms cross-entropy across the majority of datasets and architectures, sometimes by a significant margin. No additional parameter modification except for adjusting the learning rate was necessary for most datasets. For datasets with a large number of classes (42 or more) we used additional loss rescaling to accelerate training. We note that all models used in our experiments were originally designed and tuned for training with the cross-entropy loss. We conjecture that if the neural architectures were selected and tuned for the square loss, performance would be further improved and no extra loss rescaling parameters would be necessary. Another important observation is that the final softmax layer, commonly used with cross-entropy, needs to be removed during training with the square loss.
+
+While we could only explore a small sample of modern models and learning tasks, we believe that the scope of our experiments — ten different neural architectures and ten different datasets across three major application domains — is broad enough to be indicative of the wide spectrum of neural models and datasets. Our empirical results suggest amending best practices of deep learning to include training with square loss for classification problems on equal footing with cross-entropy or even as a preferred option. They also suggest that new theoretical analyses and intuitions need to be developed to understand the important question of training loss function selection.
+
+# ACKNOWLEDGMENTS
+
+The authors acknowledge support from NSF (IIS-1815697) and NIH (R01EB022899) and a Google Faculty Research Award. We thank Nvidia for the donation of GPUs and Google for the free access to the cloud TPUs provided by the TFRC program. LH thanks Wuwei Lan for helpful discussions on NLP experiments and Peidong Wang for discussions on ASR experiments. MB thanks his co-authors on (Muthukumar et al., 2020), D. Hsu, V. Multukumar, A. Narang, A. Sahai and V. Subramanian, for insightful discussions related to loss functions and the Simons Institute for the Theory of Computing, where the initial discussions took place. We thank Ryan Rifkin for valuable feedback.
+
+# REFERENCES
+
+Shaojie Bai, J Zico Kolter, and Vladlen Koltun. An empirical evaluation of generic convolutional and recurrent networks for sequence modeling. arXiv preprint arXiv:1803.01271, 2018.   
+Glenn W Brier. Verification of forecasts expressed in terms of probability. Monthly weather review, 78(1):1–3, 1950.   
+Qian Chen, Xiaodan Zhu, Zhen-Hua Ling, Si Wei, Hui Jiang, and Diana Inkpen. Enhanced LSTM for natural language inference. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, pp. 1657–1668, 2017.   
+Ahmet Demirkaya, Jiasi Chen, and Samet Oymak. Exploring the role of loss functions in multiclass classification. In 2020 54th Annual Conference on Information Sciences and Systems (CISS), pp. 1–5. IEEE, 2020.   
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.   
+William B Dolan and Chris Brockett. Automatically constructing a corpus of sentential paraphrases. In Proceedings of the Third International Workshop on Paraphrasing (IWP2005), 2005.   
+Yarin Gal and Zoubin Ghahramani. Dropout as a bayesian approximation: Representing model uncertainty in deep learning. In international conference on machine learning, pp. 1050–1059, 2016.   
+John S Garofolo, Lori F Lamel, William M Fisher, Jonathan G Fiscus, and David S Pallett. Darpa timit acoustic-phonetic continous speech corpus cd-rom. nist speech disc 1-1.1. NASA STI/Recon technical report n, 93, 1993.   
+Pavel Golik, Patrick Doetsch, and Hermann Ney. Cross-entropy vs. squared error training: a theoretical and experimental comparison. In Interspeech, volume 13, pp. 1756–1760, 2013.   
+Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016. http: //www.deeplearningbook.org.   
+Frank E Harrell Jr. Regression modeling strategies: with applications to linear models, logistic and ordinal regression, and survival analysis. Springer, 2015.   
+Hua He and Jimmy Lin. Pairwise word interaction modeling with deep neural networks for semantic similarity measurement. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 937–948, 2016.   
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.   
+Shankar Iyer, Nikhil Dandekar, and Kornel Csernai. First Quora Dataset Release: Question Pairs. ´ In https://data.quora.com/First-Quora-Dataset-Release-Question-Pairs, 2017.   
+Katarzyna Janocha and Wojciech Marian Czarnecki. On loss functions for deep neural networks in classification. arXiv preprint arXiv:1702.05659, 2017.
+
+Ziwei Ji and Matus Telgarsky. The implicit bias of gradient descent on nonseparable data. In Conference on Learning Theory, pp. 1772–1798, 2019.
+
+Dan Jurafsky. Speech & language processing. Pearson Education India, 2000.
+
+Suyoun Kim, Takaaki Hori, and Shinji Watanabe. Joint ctc-attention based end-to-end speech recognition using multi-task learning. In 2017 IEEE international conference on acoustics, speech and signal processing (ICASSP), pp. 4835–4839. IEEE, 2017.
+
+Douglas M Kline and Victor L Berardi. Revisiting squared-error and cross-entropy functions for training neural network classifiers. Neural Computing & Applications, 14(4):310–318, 2005.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Wuwei Lan and Wei Xu. Neural network models for paraphrase identification, semantic textual similarity, natural language inference, and question answering. In Proceedings of the 27th International Conference on Computational Linguistics, pp. 3890–3902, 2018.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Sebastien Marcel and Yann Rodriguez. Torchvision the machine-vision package of torch. In ´ Proceedings of the 18th ACM international conference on Multimedia, pp. 1485–1488, 2010.
+
+Niko Moritz, Takaaki Hori, and Jonathan Le Roux. Triggered attention for end-to-end speech recognition. In ICASSP 2019-2019 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5666–5670. IEEE, 2019.
+
+Vidya Muthukumar, Adhyyan Narang, Vignesh Subramanian, Mikhail Belkin, Daniel Hsu, and Anant Sahai. Classification vs regression in overparameterized regimes: Does the loss function matter?, 2020.
+
+Vassil Panayotov, Guoguo Chen, Daniel Povey, and Sanjeev Khudanpur. Librispeech: an asr corpus based on public domain audio books. In 2015 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5206–5210. IEEE, 2015.
+
+Douglas B Paul and Janet M Baker. The design for the wall street journal-based csr corpus. In Proceedings of the workshop on Speech and Natural Language, pp. 357–362. Association for Computational Linguistics, 1992.
+
+Qichao Que and Mikhail Belkin. Back to the future: Radial basis function networks revisited. In Arthur Gretton and Christian C. Robert (eds.), Proceedings of the 19th International Conference on Artificial Intelligence and Statistics, volume 51 of Proceedings of Machine Learning Research, pp. 1375–1383, Cadiz, Spain, 2016. PMLR.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: $1 0 0 { , } 0 0 0 { + }$ questions for machine comprehension of text. arXiv preprint arXiv:1606.05250, 2016.
+
+Ryan Michael Rifkin. Everything old is new again: a fresh look at historical approaches in machine learning. PhD thesis, MaSSachuSettS InStitute of Technology, 2002.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li FeiFei. Imagenet large scale visual recognition challenge. International journal of computer vision, 115(3):211–252, 2015.
+
+Arash Sangari and William Sethares. Convergence analysis of two loss functions in soft-max regression. IEEE Transactions on Signal Processing, 64(5):1280–1288, 2015.
+
+Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew $\mathrm { ~ Y ~ N ~ g ~ } _ { }$ and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 conference on empirical methods in natural language processing, pp. 1631–1642, 2013.
+
+Daniel Soudry, Elad Hoffer, Mor Shpigel Nacson, Suriya Gunasekar, and Nathan Srebro. The implicit bias of gradient descent on separable data. The Journal of Machine Learning Research, 19 (1):2822–2878, 2018.   
+Mingxing Tan and Quoc V Le. Efficientnet: Rethinking model scaling for convolutional neural networks. arXiv preprint arXiv:1905.11946, 2019.   
+Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R Bowman. Glue: A multi-task benchmark and analysis platform for natural language understanding. arXiv preprint arXiv:1804.07461, 2018.   
+Shinji Watanabe, Takaaki Hori, Shigeki Karita, Tomoki Hayashi, Jiro Nishitoba, Yuya Unno, Nelson Enrique Yalta Soplin, Jahn Heymann, Matthew Wiesner, Nanxin Chen, Adithya Renduchintala, and Tsubasa Ochiai. Espnet: End-to-end speech processing toolkit. In Interspeech, pp. 2207–2211, 2018. doi: 10.21437/Interspeech.2018-1456. URL http://dx.doi.org/10. 21437/Interspeech.2018-1456.   
+Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, R’emi Louf, Morgan Funtowicz, and Jamie Brew. Huggingface’s transformers: State-of-the-art natural language processing. ArXiv, abs/1910.03771, 2019.   
+Chen Xing, Sercan Arik, Zizhao Zhang, and Tomas Pfister. Distance-based learning from errors for confidence calibration. arXiv preprint arXiv:1912.01730, 2019.   
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.   
+Aston Zhang, Zachary C. Lipton, Mu Li, and Alexander J. Smola. Dive into Deep Learning. 2020. https://d2l.ai.
+
+# APPENDICES
+
+# A DATASETS AND TASKS
+
+Below we provide a summary of datasets used in the experiments.
+
+# NLP tasks
+
+• MRPC (Microsoft Research Paraphrase Corpus) (Dolan & Brockett, 2005) is a corpus of sentence pairs extracted from online news sources. Human annotation indicates whether the sentences in the pair are semantically equivalent. We report accuracy and F1 score. SST-2 (The Stanford Sentiment Treebank) (Socher et al., 2013) is a task to determine the sentiment of a given sentence. This corpus contains sentences from movie reviews and their sentiment given by human annotations. We use only sentence-level labels, and predict positive or negative sentiment. QNLI is a converted dataset from the Stanford Question Answering Dataset (Rajpurkar et al., 2016) which consists of question-paragraph pairs. As in (Wang et al., 2018), this task is to predict whether the context sentence selected from the paragraph contains the answer to the question. QQP (Quora Question Pairs dataset) (Iyer et al., 2017) contains question pairs from the question-answering website Quora. Similar to MRPC, this task is to determine whether a pair of questions are semantically equivalent. We report accuracy and F1 score.
+
+# ASR tasks
+
+• TIMIT (Garofolo et al., 1993) consists of speech from American English speakers, along with the corresponding phonemical and lexical transcription. It is widely used for acousticphonetic classification and ASR tasks. Its training set, validation set and test set are 3.2 hours, 0.15 hours, 0.15 hours long, respectively.
+
+• WSJ (Wall Street Journal corpus) (Paul & Baker, 1992) contains read articles from the Wall Street Journal newspaper. Its training, validation and test set are 80 hours, 1.1 hours and 0.7 hours long, respectively. Librispeech (Panayotov et al., 2015) is a large-scale (1000 hours in total) corpus of 16 kHz English speech derived from audiobooks. We choose the subset train-clean-100 (100 hours) as our training data, dev-clean (2.8 hours) as our validation set and test-clean (2.8 hours) as our test set.
+
+# Vision tasks
+
+• MNIST (LeCun et al., 1998) contains 60, 000 training images and 10, 000 testing $2 8 \times 2 8$ pixel images of hand-written digits. It is a 10-class image classification task. CIFAR-10 (Krizhevsky & Hinton, 2009) consists of $5 0 , 0 0 0 3 2 \times 3 2$ pixel training images and $1 0 , 0 0 0 3 2 \times 3 2$ pixel test images in 10 different classes. It is a balanced dataset with $6 , 0 0 0$ images of each class. ImageNet (Russakovsky et al., 2015) is an image dataset with 1000 classes, and about 1.28 million images as training set. The sizes of its validation and test set are $5 0 , 0 0 0$ and 10, 000, respectively. All images we use are in $2 2 4 \times 2 2 4$ pixels.
+
+# B HYPER-PARAMETER SETTINGS
+
+We give the implementation toolkits and specific hyper-parameter settings to help reproduce our results, and list the epochs needed for training with the square loss and the cross-entropy (CE) loss. The data processing is following the standard methods. For NLP tasks, it is the same as in (Wang et al., 2018), and for ASR tasks, it is the same as in (Watanabe et al., 2018). For vision tasks, we are following the default ones given in the implementation of the corresponding papers.
+
+# B.1 HYPER-PARAMETERS FOR NLP TASKS
+
+The implementation of BERT is based on the PyTorch toolkit (Wolf et al., 2019). The specific script we run is https://github.com/huggingface/transformers/blob/master/ examples/text-classification/run_glue.py, and we use the bert-base-cased model for fine-tuning. LSTM $+$ Attention and LSTM+CNN are implemented based on the toolkit released by (Lan & Xu, 2018). The specific hyper-parameters used in the experiments are in Table 10. As there are many hyper-parameters, we only list the key ones, and all other parameters are the default in the scripts.
+
+Table 10: Hyper-parameters for NLP tasks   
+
+<table><tr><td rowspan=2 colspan=1>Model</td><td rowspan=2 colspan=1>Task</td><td rowspan=2 colspan=1>Batchsize</td><td rowspan=2 colspan=1>max_seqlength</td><td rowspan=1 colspan=2>Learning rate w/</td><td rowspan=1 colspan=2>Epochs training w/</td></tr><tr><td rowspan=1 colspan=1>square loss</td><td rowspan=1 colspan=1>CE</td><td rowspan=1 colspan=1>square loss</td><td rowspan=1 colspan=1>CE</td></tr><tr><td rowspan=4 colspan=1>BERT</td><td rowspan=1 colspan=1>MRPC</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>5e-5</td><td rowspan=1 colspan=1>2e-5</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>SST-2</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>2e-5</td><td rowspan=1 colspan=1>2e-5</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>2e-5</td><td rowspan=1 colspan=1>2e-5</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>2e-5</td><td rowspan=1 colspan=1>2e-5</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=3 colspan=1>LSTM+Attention</td><td rowspan=1 colspan=1>MRPC</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>2e-4</td><td rowspan=1 colspan=1>1e-4</td><td rowspan=1 colspan=1>25</td><td rowspan=1 colspan=1>20</td></tr><tr><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>sent_len*</td><td rowspan=1 colspan=1>1e-4</td><td rowspan=1 colspan=1>1e-4</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td></tr><tr><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>120</td><td rowspan=1 colspan=1>1e-4</td><td rowspan=1 colspan=1>1e-4</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>30</td></tr><tr><td rowspan=3 colspan=1>LSTM+CNN</td><td rowspan=1 colspan=1>MRPC</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>2e-4</td><td rowspan=1 colspan=1>1e-4</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td></tr><tr><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>sent_len*</td><td rowspan=1 colspan=1>8e-5</td><td rowspan=1 colspan=1>1e-4</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td></tr><tr><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>120</td><td rowspan=1 colspan=1>1e-3</td><td rowspan=1 colspan=1>1e-3</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td></tr></table>
+
+\* The max sequence length equals the max sentence length of the training set.
+
+# B.2 HYPER-PARAMETERS FOR ASR TASKS
+
+The implementation of ASR tasks is based on the ESPnet (Watanabe et al., 2018) toolkit, and the specific code we use is the run.sh script under the base folder of each task, which is https:
+
+//github.com/espnet/espnet/tree/master/egs/?/asr1, where ’?’ can be ’timit’, ’wsj’, and ’librispeech’. The specific hyper-parameters are following the ones in the configuration file of each task, which is under the base folder. We list the files which give the hyper-parameter settings for acoustic model training in Table 11.
+
+Table 11: Hyper-parameters for ASR tasks   
+
+<table><tr><td rowspan=2 colspan=1>Model</td><td rowspan=2 colspan=1>Task</td><td rowspan=2 colspan=1>Hyper-parameters</td><td rowspan=1 colspan=1>Epochs training w/</td><td rowspan=1 colspan=1>ingw/</td></tr><tr><td rowspan=1 colspan=1>square loss</td><td rowspan=1 colspan=1>CE</td></tr><tr><td rowspan=1 colspan=1>Attention+CTC</td><td rowspan=1 colspan=1>TIMIT</td><td rowspan=1 colspan=1>conf/train.yaml</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td></tr><tr><td rowspan=1 colspan=1>VGG+BLSTMP</td><td rowspan=1 colspan=1>WSJ*</td><td rowspan=1 colspan=1>conf/tuning/train_rnn.yaml</td><td rowspan=1 colspan=1>15</td><td rowspan=1 colspan=1>15</td></tr><tr><td rowspan=1 colspan=1>VGG+BLSTM</td><td rowspan=1 colspan=1>Librispeech</td><td rowspan=1 colspan=1>conf/tuning/train_rnn.yaml</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>20</td></tr></table>
+
+\* For WSJ, we use the language model given by https://drive.google.com/ open?id ${ . } =$ 1Az-4H25uwnEFa4lENc-EKiPaWXaijcJp. \ We set mtlalpha $= 0 . 3$ , batch-size $\scriptstyle = 3 0$ . ♦ We set elayers $^ { = 4 }$ , as we use 100 hours training data.
+
+# B.3 HYPER-PARAMETERS FOR VISION TASKS
+
+The implementation of these models are based on the open source toolkits. For TCNN and EfficientNet, we use the open source implementation given by (Bai et al., 2018) and (Tan & Le, 2019), respectively. For Wide ResNet, we are based on the open source PyTorch implementation https: //github.com/xternalz/WideResNet-pytorch (W-ResNet). For ResNet-50, our experiments are based on the Tensorflow toolkit https://github.com/tensorflow/tpu/ tree/master/models/official/resnet (ResNet) implemented on TPU. The hyperparameter settings for our vision experiments are in Table 12.
+
+Table 12: Hyper-parameters for vision tasks   
+
+<table><tr><td rowspan=2 colspan=1>Model</td><td rowspan=2 colspan=1>Task</td><td rowspan=2 colspan=1>Hyper-parameters</td><td rowspan=1 colspan=2>Epochs training w/</td></tr><tr><td rowspan=1 colspan=1>square loss</td><td rowspan=1 colspan=1>CE</td></tr><tr><td rowspan=1 colspan=1>TCNN</td><td rowspan=1 colspan=1>MNIST4</td><td rowspan=1 colspan=1>the default in (Bai et al., 2018)</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td></tr><tr><td rowspan=1 colspan=1>Wide-ResNet</td><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>the default in W-ResNet,except wide-factor=20</td><td rowspan=1 colspan=1>200</td><td rowspan=1 colspan=1>200</td></tr><tr><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>ImageNet</td><td rowspan=1 colspan=1>the default in ResNet,for square loss, learning rate=0.3</td><td rowspan=1 colspan=1>168885*</td><td rowspan=1 colspan=1>112590*</td></tr><tr><td rowspan=1 colspan=1>EfficientNet</td><td rowspan=1 colspan=1>ImageNet</td><td rowspan=1 colspan=1>the default in EfficientNet-BOof (Tan &amp; Le,2019)</td><td rowspan=1 colspan=1>218949*</td><td rowspan=1 colspan=1>218949*</td></tr></table>
+
+\ We are doing the permuted MNIST task as in Bai et al. (2018). \* We give the training steps as in the original implementations.
+
+# C EXPERIMENTAL RESULTS ON VALIDATION AND TRAINING SETS
+
+Table 13: NLP results on validation set, accuracy   
+
+<table><tr><td>Model</td><td>Task</td><td>train with square loss (%)</td><td>train with cross-entropy (%)</td><td>square loss w/ same epochs as CE (%)</td></tr><tr><td rowspan="4">BERT (Devlin et al., 2018)</td><td>MRPC</td><td>85.3</td><td>85.0</td><td>85.3</td></tr><tr><td>SST-2</td><td>91.2</td><td>91.5</td><td>91.2</td></tr><tr><td>QNLI</td><td>90.8</td><td>90.7</td><td>90.8</td></tr><tr><td>QQP</td><td>90.8</td><td>90.7</td><td>90.6</td></tr><tr><td rowspan="2">LSTM+Attention (Chen et al., 2017)</td><td>MRPC</td><td>76.5</td><td>74.8</td><td>75.3</td></tr><tr><td>QNLI</td><td>79.7</td><td>79.7</td><td>79.7</td></tr><tr><td rowspan="3">LSTM+CNN (He &amp; Lin,2016)</td><td>QQP</td><td>86.0</td><td>85.5</td><td>86.0</td></tr><tr><td>MRPC</td><td>76.0</td><td>73.3</td><td>76.0</td></tr><tr><td>QNLI QQP</td><td>76.8 84.0</td><td>76.8 85.3</td><td>76.8 84.0</td></tr></table>
+
+Table 14: NLP results on validation set, F1 scores   
+
+<table><tr><td>Model</td><td>Task</td><td>train with square loss (%)</td><td>train with cross-entropy (%)</td><td>square loss w/ same epochs as CE (%)</td></tr><tr><td>BERT</td><td>MRPC</td><td>89.5</td><td>89.6</td><td>89.5</td></tr><tr><td>(Devlin et al., 2018)</td><td>QQP</td><td>87.5</td><td>87.4</td><td>87.4</td></tr><tr><td>LSTM+Attention</td><td>MRPC</td><td>83.7</td><td>83.3</td><td>83.5</td></tr><tr><td>(Chen et al., 2017)</td><td>QQP</td><td>82.1</td><td>81.7</td><td>82.1</td></tr><tr><td>LSTM+CNN</td><td>MRPC</td><td>82.6</td><td>81.4</td><td>82.6</td></tr><tr><td>(He &amp; Lin, 2016)</td><td>QQP</td><td>77.4</td><td>80.2</td><td>77.4</td></tr></table>
+
+We report the results for validation set of NLP tasks in Table 13 for accuracy and Table 14 for F1 scores.
+
+The validation set results of the ASR tasks are in Table 15.
+
+Table 15: ASR results on validation set, error rate   
+
+<table><tr><td>Model</td><td>Task</td><td>train with square loss (%)</td><td>train with cross-entropy (%)</td><td>square loss w/ same epochs as CE (%)</td></tr><tr><td>Attention+CTC</td><td>TIMIT (PER)</td><td>18.1</td><td>18.3</td><td>18.1</td></tr><tr><td>(Kim et al., 2017)</td><td>TIMIT (CER)</td><td>30.4</td><td>31.4</td><td>30.4</td></tr><tr><td>VGG+BLSTMP</td><td>WSJ (WER)</td><td>8.5</td><td>8.8</td><td>8.5</td></tr><tr><td>(Moritz et al., 2019)</td><td>WSJ (CER)</td><td>3.9</td><td>4.0</td><td>3.9</td></tr><tr><td>VGG+BLSTM</td><td>Librispeech (WER)</td><td>9.3</td><td>10.7</td><td>9.9</td></tr><tr><td>(Moritz et al., 2019)</td><td>Librispeech (CER)</td><td>9.4</td><td>11.1</td><td>10.2</td></tr></table>
+
+We report the training result for NLP tasks in Table 16 for accuracy and F1 score in Table 17. The training results for ASR tasks and vision tasks are in Table 18 and Table 19, respectively.
+
+Table 16: NLP results on training and test set, accuracy   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Task</td><td colspan="2">train with square loss (%)</td><td colspan="2">train with cross-entropy (%)</td><td colspan="2">square loss w/ same epochs as CE (%)</td></tr><tr><td>Train</td><td>Test</td><td>Train</td><td>Test</td><td>Train</td><td>Test</td></tr><tr><td rowspan="4">BERT (Devlin et al., 2018)</td><td>MRPC</td><td>99.7</td><td>83.8</td><td>99.9</td><td>82.1</td><td>99.6</td><td>83.6</td></tr><tr><td>SST-2</td><td>98.6</td><td>94.0</td><td>99.2</td><td>93.9</td><td>98.6</td><td>93.9</td></tr><tr><td>QNLI</td><td>98.0</td><td>90.6</td><td>97.5</td><td>90.6</td><td>98.0</td><td>90.6</td></tr><tr><td>QQP</td><td>96.2</td><td>88.9</td><td>98.0</td><td>88.9</td><td>96.2</td><td>88.8</td></tr><tr><td rowspan="3">LSTM+Attention (Chen et al., 2017)</td><td>MRPC</td><td>94.6</td><td>71.7</td><td>84.9</td><td>70.9</td><td>93.2</td><td>71.5</td></tr><tr><td>QNLI</td><td>87.7</td><td>79.3</td><td>90.8</td><td>79.0</td><td>87.7</td><td>79.3</td></tr><tr><td>QQP</td><td>93.7</td><td>83.4</td><td>91.5</td><td>83.1</td><td>93.7</td><td>83.4</td></tr><tr><td rowspan="3">LSTM+CNN (He &amp; Lin,2016)</td><td>MRPC</td><td>98.3</td><td>73.2</td><td>92.5</td><td>69.4</td><td>98.3</td><td>72.5</td></tr><tr><td>QNLI</td><td>92.8</td><td>76.0</td><td>90.7</td><td>76.0</td><td>92.8</td><td>76.0</td></tr><tr><td>QQP</td><td>91.3</td><td>84.3</td><td>95.7</td><td>84.4</td><td>91.3</td><td>84.3</td></tr></table>
+
+Table 17: NLP results on training and test set, F1 scores   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Task</td><td colspan="2">train with square loss (%)</td><td colspan="2">train with cross-entropy (%)</td><td colspan="2">square loss w/ same epochs as CE (%)</td></tr><tr><td>Train</td><td>Test</td><td>Train</td><td>Test</td><td>Train</td><td>Test</td></tr><tr><td>BERT</td><td>MRPC</td><td>99.8</td><td>88.1</td><td>99.9</td><td>86.7</td><td>99.7</td><td>88.0</td></tr><tr><td>(Devlin et al., 2018)</td><td>QQP</td><td>94.5</td><td>70.9</td><td>97.2</td><td>70.7</td><td>94.5</td><td>70.7</td></tr><tr><td>LSTM+Attention (Chen et al., 2017)</td><td>MRPC QQP</td><td>96.1 91.9</td><td>80.9 62.6</td><td>89.5 89.2</td><td>80.6 62.3</td><td>94.7 91.9</td><td>80.7 62.6</td></tr><tr><td>LSTM+CNN</td><td>MRPC</td><td>98.8</td><td>81.0</td><td>94.5</td><td>78.2</td><td>98.8</td><td>81.0</td></tr><tr><td>(He &amp; Lin, 2016)</td><td>QQP</td><td>88.0</td><td>60.3</td><td>94.2</td><td>60.5</td><td>88.0</td><td>60.3</td></tr></table>
+
+Table 18: ASR results on training and test set, error rate   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Task</td><td colspan="2">train with square loss (%)</td><td colspan="2">trainwith cross-entropy (%)</td><td colspan="2">square loss w/ same epochs as CE (%)</td></tr><tr><td>Train</td><td>Test</td><td>Train</td><td>Test</td><td>Train</td><td>Test</td></tr><tr><td>Attention+CTC</td><td>TIMIT (PER)</td><td>0.9</td><td>20.8</td><td>4.8</td><td>20.8</td><td>0.9</td><td>20.8</td></tr><tr><td>(Kim et al.,2017)</td><td>TIMIT (CER)</td><td>4.5</td><td>32.5</td><td>11.6</td><td>33.4</td><td>4.5</td><td>32.5</td></tr><tr><td>VGG+BLSTMP</td><td>WSJ (WER)*</td><td>0.7</td><td>5.1</td><td>0.3</td><td>5.3</td><td>0.7</td><td>5.1</td></tr><tr><td>(Moritz et al., 2019)</td><td>WSJ(CER)*</td><td>0.3</td><td>2.4</td><td>0.1</td><td>2.5</td><td>0.3</td><td>2.4</td></tr><tr><td>VGG+BLSTM</td><td>Librispeech (WER)*</td><td>0.8</td><td>9.8</td><td>0.4</td><td>10.6</td><td>0.8</td><td>10.3</td></tr><tr><td>(Moritz et al., 2019)</td><td>Librispeech (CER)*</td><td>0.6</td><td>9.7</td><td>0.3</td><td>10.7</td><td>0.6</td><td>10.2</td></tr></table>
+
+\* For WSJ and Librispeech, we take $1 0 \%$ of the training set for the evaluation of the training error rate.
+
+Table 19: Vision results on training and test set, accuracy   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Task</td><td colspan="2">train with square loss (%)</td><td colspan="2">train with cross-entropy (%)</td><td colspan="2">square loss w/ same epochs as CE(%)</td></tr><tr><td>Train</td><td>Test</td><td>Train</td><td>Test</td><td>Train</td><td>Test</td></tr><tr><td>TCNN (Bai et al., 2018)</td><td>MNIST (acc.)</td><td>98.3</td><td>97.7</td><td>99.5</td><td>97.7</td><td>98.3</td><td>97.7</td></tr><tr><td>W-Resnet (Zagoruyko &amp; Komodakis,2016)</td><td>CIFAR-10 (acc.)</td><td>100.0</td><td>95.9</td><td>100.0</td><td>96.3</td><td>100.0</td><td>95.9</td></tr><tr><td>ResNet-50</td><td>ImageNet (acc.)</td><td>77.7</td><td>76.2</td><td>80.5</td><td>76.1</td><td>77.7</td><td>76.0</td></tr><tr><td>(He et al., 2016)</td><td>ImageNet (Top-5 acc.)</td><td>93.2</td><td>93.0</td><td>93.4</td><td>93.0</td><td>93.2</td><td>92.9</td></tr><tr><td>EfficientNet</td><td>ImageNet (acc.)</td><td>75.1</td><td>74.6</td><td>81.4</td><td>77.0</td><td>75.1</td><td>74.6</td></tr><tr><td>(Tan &amp; Le,2019)</td><td>ImageNet (Top-5 acc.)</td><td>93.0</td><td>92.7</td><td>94.0</td><td>93.3</td><td>93.0</td><td>92.7</td></tr></table>
+
+# D OUR RESULTS COMPARED WITH THE ORIGINAL WORK
+
+We list our results for the models trained with the cross-entropy (CE) loss and compare them to the results reported in the literature or the toolkits in Table 20. As we observe, our results are comparable to the original reported results.
+
+Table 20: Training with the cross-entropy loss, our results and the reported ones   
+
+<table><tr><td>Model</td><td>Task</td><td>Our CE result</td><td>CE result in the literature</td></tr><tr><td rowspan="4">BERT*</td><td>MRPC (acc./F1)</td><td>85.0/89.6</td><td>85.29/89.47 (Wolf et al., 2019)</td></tr><tr><td>SST-2 (acc.)</td><td>91.5</td><td>91.97 (Wolf et al.,2019)</td></tr><tr><td>QNLI (acc.)</td><td>90.7</td><td>87.46 (Wolf et al., 2019)</td></tr><tr><td>QQP (acc./F1)</td><td>90.7/87.4</td><td>88.40/84.31 (Wolf et al., 2019)</td></tr><tr><td>LSTM+Attention LSTM+CNN</td><td></td><td></td><td>N/A N/A</td></tr><tr><td rowspan="2">Attention+CTC</td><td>TIMIT (PER)</td><td></td><td></td></tr><tr><td>TIMIT (CER)</td><td>20.7</td><td>20.5 (Watanabe et al.,2018)</td></tr><tr><td rowspan="2">VGG+BLSTMP</td><td></td><td>32.7</td><td>33.7 (Watanabe et al.,2018)</td></tr><tr><td>WSJ (WER)</td><td>5.4</td><td>5.3 (Watanabe et al., 2018)</td></tr><tr><td rowspan="2">VGG+BLSTM</td><td>WSJ (CER)</td><td>2.6</td><td>2.4 (Watanabe et al., 2018)</td></tr><tr><td>Librispeech (WER)</td><td>10.8</td><td>N/A</td></tr><tr><td>TCNN</td><td>Librispeech (CER) MNIST (acc.)</td><td>11.0 98.0</td><td>N/A</td></tr><tr><td>Wide-ResNet</td><td>CIFAR-10 (acc.)</td><td>96.5</td><td>97.2 (Bai et al., 2018)</td></tr><tr><td>ResNet-50</td><td>ImageNet (acc./Top-5 acc.)</td><td>76.1/93.0</td><td>96.11 (Zagoruyko &amp; Komodakis, 2016) 76.0/93.0 (Tan &amp; Le,2019)</td></tr><tr><td>EfficientNet</td><td>ImageNet (acc./Top-5 acc.)</td><td>77.2/93.4</td><td>77.3/93.5 (Tan &amp; Le,2019)</td></tr></table>
+
+\* The implementation in (Wolf et al., 2019) is using bert-base-uncased model, we are using bert-base-cased, which will result in a little difference. Also, as they didn’t give test set results, here for BERT, we give the results of validation set.
+
+The models marked with ’N/A’ in Table 20 do not have comparable results reported in the literature. Specifically, LSTM $+$ Attention and LSTM $+$ CNN models for NLP tasks are implemented based on the toolkit released by (Lan & Xu, 2018), where they did not show results on MRPC and QNLI. The QQP results are not comparable with ours as they were using a different test set, while we are using the standard test set same as in (Wang et al., 2018). The VGG $^ +$ BLSTM model for Librispeech dataset is based on ESPnet toolkit (Watanabe et al., 2018). Due to computational resources limitations, we only use train-clean-100 (100 hours) as training data and 1000 unigram based dictionary for acoustic model training, while they use 1000 hours of training data with at least 2000 unigram dictionary.
+
+# E REGULARIZATION TERMS
+
+We give the regularization term of each task in Table 21. 0 means we didn’t add regularization term. For WSJ, check the details at line 306 of https://github.com/espnet/espnet/blob/ master/espnet/nets/pytorch_backend/rnn/decoders.py.
+
+Table 21: Regularization term for each task   
+
+<table><tr><td>Model</td><td>Task</td><td>dropout*</td><td>batch norm</td><td>Regularization Term</td></tr><tr><td>BERT</td><td>MRPC/SST-2/QNLI/QQP</td><td>0.1</td><td>N</td><td>0</td></tr><tr><td>LSTM+Attention</td><td>MRPC/QNLI/QQP</td><td>0.5</td><td>N</td><td>0</td></tr><tr><td>LSTM+CNN</td><td>MRPC/QNLI/QQP</td><td>0.0</td><td>N</td><td>0</td></tr><tr><td>Attention+CTC</td><td>TIMIT</td><td>0.0</td><td>N</td><td>0</td></tr><tr><td>VGG+BLSTMP</td><td>WSJ</td><td>0.0</td><td>N</td><td>label smoothing based</td></tr><tr><td>VGG+BLSTM</td><td>Librispeech</td><td>0.0</td><td>N</td><td>0</td></tr><tr><td>TCN</td><td>MNIST</td><td>0.05</td><td>N</td><td>0</td></tr><tr><td>Wide-ResNet</td><td>CIFAR-10</td><td>0.0</td><td>N</td><td>0</td></tr><tr><td>ResNet-50</td><td>ImageNet</td><td>0.0</td><td>Y</td><td>10-4 一n 2 ∑i=1</td></tr><tr><td>EfficientNet</td><td>ImageNet</td><td>0.0</td><td>Y</td><td>10-5 n 2 i=</td></tr></table>
+
+∗ For dropout, 0.0 means have not apply dropout.
+
+# F VARIANCE OF ACCURACY AMONG DIFFERENT RANDOM SEEDS
+
+Figure 3 gives the error bar of 5 runs corresponding to 5 different random seeds, along with the results for each inidividual run. In the left of each subfigure is the result of training with the square loss, while in the right is result of the cross-entropy. As can be seen in Figure 3, using the square loss has better accuray/error rate and smaller variance in NLP and ASR tasks, which indicates that training with the square loss for those classification tasks is statistically better.
+
+![](images/e7fe6f296bc8becee021a4cfccdc5faa4859627edae09fbd4bae5d6f54a8fb85.jpg)  
+Accuracy among results of 5 random seeds   
+Accuracy among results of 5 random seeds   
+Figure 3: Accuracy/error rate variance of results among 5 random seeds

parse/train/hsFN92eQEla/hsFN92eQEla_content_list.json

@@ -0,0 +1,1672 @@
+[
+    {
+        "type": "text",
+        "text": "EVALUATION OF NEURAL ARCHITECTURES TRAINED WITH SQUARE LOSS VS CROSS-ENTROPY IN CLASSIFICATION TASKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Like Hui   \nComputer Science and Engineering   \nUniversity of California, San Diego   \nSan Diego, CA 92093   \nlhui@ucsd.edu   \nMikhail Belkin   \nHalıcıoglu Data Science Institute ˘   \nUniversity of California, San Diego   \nSan Diego, CA 92093   \nmbelkin@ucsd.edu ",
+        "bbox": [
+            183,
+            195,
+            418,
+            265
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            506,
+            195,
+            741,
+            265
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            301,
+            544,
+            316
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Modern neural architectures for classification tasks are trained using the crossentropy loss, which is widely believed to be empirically superior to the square loss. In this work we provide evidence indicating that this belief may not be wellfounded. We explore several major neural architectures and a range of standard benchmark datasets for NLP, automatic speech recognition (ASR) and computer vision tasks to show that these architectures, with the same hyper-parameter settings as reported in the literature, perform comparably or better when trained with the square loss, even after equalizing computational resources. Indeed, we observe that the square loss produces better results in the dominant majority of NLP and ASR experiments. Cross-entropy appears to have a slight edge on computer vision tasks. ",
+        "bbox": [
+            233,
+            342,
+            764,
+            494
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We argue that there is little compelling empirical or theoretical evidence indicating a clear-cut advantage to the cross-entropy loss. Indeed, in our experiments, performance on nearly all non-vision tasks can be improved, sometimes significantly, by switching to the square loss. Furthermore, training with square loss appears to be less sensitive to the randomness in initialization. We posit that training using the square loss for classification needs to be a part of best practices of modern deep learning on equal footing with cross-entropy. ",
+        "bbox": [
+            233,
+            502,
+            764,
+            599
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            648,
+            336,
+            664
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Modern deep neural networks are nearly universally trained with cross-entropy loss in classification tasks. To illustrate, cross-entropy is the only loss function specifically discussed in connection with training neural networks for classification in popular references (Goodfellow et al., 2016; Zhang et al., 2020). It is the default for classification in widely used packages such as NLP implementation Hugging Face Transformers (Wolf et al., 2019), speech classification by ESPnet (Watanabe et al., 2018) and image classification implemented by torchvision (Marcel & Rodriguez, 2010). Yet we know of few empirical evaluations or compelling theoretical analyses to justify the predominance of cross-entropy in practice. In what follows, we use a number of modern deep learning architectures and standard datasets across the range of tasks of natural language processing, speech recognition and computer vision domains as a basis for a systematic comparison between the cross-entropy and square losses. The square loss (also known as the Brier score (Brier, 1950) in the classification context) is a particularly useful basis for comparison since it is nearly universally used for regression tasks and is available in all major software packages. To ensure a fair evaluation, for the square loss we use hyper-parameter settings and architectures exactly as reported in the literature for crossentropy, with the exception of the learning rate, which needs to be increased in comparison with cross-entropy and, for problems with a large number of classes (42 or more in our experiments), loss function rescaling (see Section 5). ",
+        "bbox": [
+            174,
+            688,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our evaluation includes 20 separate learning tasks1 (neural model/dataset combinations) evaluated in terms of the error rate or, equivalently, accuracy (depending on the prevalent domain conventions). We also provide some additional domain-specific evaluation metrics – F1 for NLP tasks, and Top-5 accuracy for ImageNet. Training with the square loss provides accuracy better or equal to that of cross-entropy in 17 out of 20 tasks. These results are for averages over multiple random initalizations, results for each individual initialization are similar. Furthermore, we find that training with the square loss has smaller variance with respect to the randomness of the initialization in the majority of our experiments. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our results indicate that the models trained using the square loss are not just competitive with same models trained with cross-entropy across nearly all tasks and settings but, indeed, provide better classification results in the majority of our experiments. The performance advantage persists even when we equalize the amount of computation by choosing the number of epochs for training the square loss to be the same as the optimal (based on validation) number of epochs for cross-entropy, a setting favorable to cross-entropy. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Note that with the exception of the learning rate, we utilized hyper-parameters reported in the literature, originally optimized for the cross-entropy loss. This suggests that further improvements in performance for the square loss can potentially be obtained by hyper-parameter tuning. ",
+        "bbox": [
+            174,
+            313,
+            823,
+            354
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Based on our results, we believe that the performance of modern architectures on a range of classification tasks may be improved by using the square loss in training. We conclude that the choice between the cross-entropy and the square loss for training needs to be an important aspect of model selection, in addition to the standard considerations of optimization methods and hyper-parameter tuning. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            431
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A historical note. The modern ubiquity of cross-entropy loss is reminiscent of the predominance of the hinge loss in the era of the Support Vector Machines (SVM). At the time, the prevailing intuition had been that the hinge loss was preferable to the square loss for training classifiers. Yet, the empirical evidence had been decidedly mixed. In his remarkable thesis (Rifkin, 2002), Ryan Rifkin conducted an extensive empirical evaluation and concluded that “the performance of the RLSC [square loss] is essentially equivalent to that of the SVM [hinge loss] across a wide range of problems, and the choice between the two should be based on computational tractability considerations”. More recently, the experimental results in (Que & Belkin, 2016) show an advantage to training with the square loss over the hinge loss across the majority of the tasks, paralleling our results in this paper. We note that conceptual or historical reasons for the current prevalence of cross-entropy in training neural networks are not entirely clear. ",
+        "bbox": [
+            173,
+            439,
+            825,
+            592
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Theoretical considerations. The accepted justification of cross-entropy and hinge loss for classification is that they are better “surrogates” for the 0-1 classification loss than the square loss, e.g. (Goodfellow et al., 2016), Section 8.1.2. There is little theoretical analysis supporting this point of view. To the contrary, the recent work (Muthukumar et al., 2020) proves that in certain overparameterized regimes, the classifiers obtained by minimizing the hinge loss and the square loss in fact the same. While the hinge loss is different from cross-entropy, these losses are closely related in certain settings (Ji & Telgarsky, 2019; Soudry et al., 2018). See (Muthukumar et al., 2020) for a more in-depth theoretical discussion of loss functions and the related literature. ",
+        "bbox": [
+            173,
+            601,
+            825,
+            712
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Probability interpretation of neural network output and calibration. An argument for using the cross-entropy loss function is sometimes based on the idea that networks trained with crossentropy are able to output probability of a new data point belonging to a given class. For linear models in the classical analysis of logistic regression, minimizing cross-entropy (logistic loss) indeed yields the maximum likelihood estimator for the model (e.g.,(Harrell Jr, 2015), Section 10.5). Yet, the relevance of that analysis to modern highly non-linear and often over-parameterized neural networks is questionable. For example, in (Gal & Ghahramani, 2016) the authors state that $^ { * } I n$ classification, predictive probabilities obtained at the end of the pipeline (the softmax output) are often erroneously interpreted as model confidence”. Similarly, the work (Xing et al., 2019) asserts that “for DNNs with conventional (also referred as ‘vanilla’) training to minimize the softmax crossentropy loss, the outputs do not contain sufficient information for well-calibrated confidence estimation”. Thus, accurate class probability estimation cannot be considered an unambiguous advantage of neural networks trained with cross-entropy. While the analysis of calibration for different loss functions is beyond the scope of this paper, we note that in many practical settings accurate classification, the primary evaluation metric of this work, takes precedence over the probability estimation. ",
+        "bbox": [
+            173,
+            720,
+            825,
+            887
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Domain applicability. It is interesting to note that in our experiments the square loss generally performs better on NLP and ASR tasks, while cross-entropy has a slight edge on computer vision. It is tempting to infer that the square loss is suitable for NLP and speech, while cross-entropy may be more appropriate for training vision architectures. Yet we are wary of over-interpreting the evidence. In particular, we observe that the cross-entropy has a significant performance advantage on just a single vision architecture (EfficientNet (Tan & Le, 2019) trained on ImageNet). The rest of the vision results are quite similar between square loss and cross-entropy and are likely to be sensitive to the specifics of optimization and parameter tuning. Understanding whether specific loss functions are better suited for certain domain will require more in-depth experimental work. ",
+        "bbox": [
+            174,
+            148,
+            825,
+            275
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Related work. The choice of a loss function is an integral and essential aspect of training neural networks. Yet we are aware of few comparative analyses of loss functions and no other systematic studies of modern architectures across a range of datasets. Kline & Berardi (2005) compared the effectiveness of squared-error versus cross-entropy in estimating posterior probabilities with small neural networks, five or less nodes in each layer, and argued that cross-entropy had a performance advantage. Golik et al. (2013) provided a comparison of cross-entropy and squared error training for a hybrid HMM/neural net model for one ASR and one handwriting recognition datasets. The authors observed that with a good initialization by pre-training, training with the squared error had better performance than the cross-entropy. Sangari & Sethares (2015) analyzed the convergence of mean squared error (MSE) and cross-entropy under the normalized logistic regression model (Soft-Max) setting, and indicated the MSE loss function is robust to the true model parameter values and can converge to the same parameter estimation variance of the cross-entropy loss function with half the number of gradient descent iterations. Janocha & Czarnecki (2017) compared several different loss functions on MNIST and CIFAR-10 datasets concluding that “depending on the application of the deep model – losses other than log loss [cross-entropy] are preferable”. A recent work (Demirkaya et al., 2020) provided a theoretical comparison of square and cross-entropy losses for training mixture models. The authors argued that the cross-entropy loss has more favorable optimization landscapes in multiclass settings. To alleviate that issue, they proposed rescaling of the loss function equivalent to choosing parameter $k$ in Section 5. The authors showed that rescaling allowed the square loss to become competitive with cross-entropy on CIFAR-100, a finding that aligns with the results in our paper. ",
+        "bbox": [
+            173,
+            279,
+            825,
+            570
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            590,
+            326,
+            606
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We conducted experiments on a number of benchmark datasets for NLP, ASR and computer vision, following the standard recipes given in recent papers of each domain. Four NLP datasets are MRPC, SST-2, QNLI and QQP. TIMIT, WSJ and Librispeech are three standard datasets used for training ASR systems. For vision experiments, we choose MNIST, CIFAR-10, and ImageNet. To the best of our knowledge, we are the first to experimentally compare the square loss and the cross-entropy on a wide range of datasets with different size, dimensionality (number of features) and the number of classes (up to 1000 class numbers). See Appendix A for references and description. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            717
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Architectures. In what follows we explore several widely used modern neural architectures. For NLP tasks, we implement classifiers with a fine-tuned BERT (Devlin et al., 2018), a LSTM+Attention model (Chen et al., 2017), and a LSTM $^ +$ CNN model (He & Lin, 2016). Joint CTC-Attention based model (Kim et al., 2017), triggered attention model with VGG and BLSTM modules (Moritz et al., 2019) are used for ASR tasks. Note that for the CTC-Attention based model, the original loss function is a weighted sum of the cross-entropy and the CTC loss. When training with the square loss, we only replace the cross-entropy to be the square loss, and keep the CTC loss untouched. For vision tasks, we use TCNN (Bai et al., 2018), Wide ResNet (Zagoruyko & Komodakis, 2016), ResNet (He et al., 2016) and EfficientNet (Tan & Le, 2019) architectures. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            842
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Experimental protocols. For training with the cross-entropy loss, we use a standard protocol, which is to stop training after the validation accuracy does not improve for five consecutive epochs. For the square loss we use two protocols. The first one is the same as for cross-entropy. The second protocol is to train the square loss using the number of epochs selected when training the cross-entropy loss with the first protocol. The second protocol is designed to equalize the usage of computational resources between the square loss and cross-entropy and is favorable to cross-entropy. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Following the hyper-parameter settings of the architectures in the literature, we re-implement the models trained with the cross-entropy loss keeping the same architecture and hyper-parameter settings. We train the same models using the square loss, employing our two experimental protocols. The only alteration to the parameters of the network reported in the literature is adjustment of the learning rate. For datasets with a large number of labels (42 or more in our experiments) we apply loss function rescaling (see Section 5). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The key points for the implementation are described in Section 5. The implementation details and specific hyper-parameter settings are given in Appendix B. See Appendix D for a summary of comparisons between the original results and our re-implementations. Additionally, we report the results on validation sets and training sets in Appendix C. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            251
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The results presented below are average results of 5 runs corresponding to 5 different random initalizations for each task. The result across initializations are given in Section 3. ",
+        "bbox": [
+            176,
+            257,
+            820,
+            285
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.1 NLP EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            303,
+            349,
+            318
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We conduct 2-class classification tasks from NLP domain. The datasets information is summarized in Table 1. As in (Wang et al., 2018), we report accuracy and F1 scores for MRPC and QQP datasets, and report accuracy for SST-2 and QNLI. ",
+        "bbox": [
+            174,
+            329,
+            821,
+            372
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/70b2e0a3b8028f615df9d8499ddb451602c35d41ec010b76299eafdbd8047fd4.jpg",
+        "table_caption": [
+            "Table 1: NLP task statistics and descriptions "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Corpus</td><td>Train</td><td>[Test</td><td>#classes</td><td>Metric</td><td>Domain</td></tr><tr><td>MRPC (Dolan &amp; Brockett, 2005)</td><td>3.7K</td><td>1.7K</td><td>2</td><td>acc./F1</td><td>news</td></tr><tr><td>SST-2 (Socher et al., 2013)</td><td>67K</td><td>1.8K</td><td></td><td>acc.</td><td>movie reviews</td></tr><tr><td>QNLI (Rajpurkar et al., 2016)</td><td>105K</td><td>5.4K</td><td></td><td>acc.</td><td>Wikipedia</td></tr><tr><td>QQP (Iyer et al., 2017)</td><td>364K</td><td>391K</td><td>２２2</td><td>acc./F1</td><td>social QA questions</td></tr></table>",
+        "bbox": [
+            178,
+            390,
+            815,
+            462
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Table 2 gives the accuracy and Table 3 gives the F1 scores of the neural models on NLP tasks. As can be seen in Table 2, in 9 out of 10 tasks using the square loss has better/equal accuracy compared with using the cross-entropy, and in terms of F1 score (see Table 3), 5 out of 6 tasks training with the square loss outperform training with the cross-entropy loss. Even with same epochs, i.e. with same computation cost, using the square loss has equal/better accuracy in 8 out of 10 tasks , and has higher F1 score in 5 out of 6 tasks. ",
+        "bbox": [
+            174,
+            469,
+            821,
+            484
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/d72fa1e24fb5422cf160aa5dd6b8ce11ce50fd63db4b804f6959d04fe9c9b371.jpg",
+        "table_caption": [
+            "Table 2: NLP results, accuracy "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Task</td><td>train with square loss (%)</td><td>train with cross-entropy (%)</td><td>square loss w/ same epochs as CE (%)</td></tr><tr><td rowspan=\"4\">BERT (Devlin et al., 2018)</td><td>MRPC</td><td>83.8</td><td>82.1</td><td>83.6</td></tr><tr><td>SST-2</td><td>94.0</td><td>93.9</td><td>93.9</td></tr><tr><td>QNLI</td><td>90.6</td><td>90.6</td><td>90.6</td></tr><tr><td>QQP</td><td>88.9</td><td>88.9</td><td>88.8</td></tr><tr><td rowspan=\"3\">LSTM+Attention (Chen et al., 2017)</td><td>MRPC</td><td>71.7</td><td>70.9</td><td>71.5</td></tr><tr><td>QNLI</td><td>79.3</td><td>79.0</td><td>79.3</td></tr><tr><td>QQP</td><td>83.4</td><td>83.1</td><td>83.4</td></tr><tr><td rowspan=\"3\">LSTM+CNN (He &amp; Lin,2016)</td><td>MRPC</td><td>73.2</td><td>69.4</td><td>72.5</td></tr><tr><td>QNLI</td><td>76.0</td><td>76.0</td><td>76.0</td></tr><tr><td>QQP</td><td>84.3</td><td>84.4</td><td>84.3</td></tr></table>",
+        "bbox": [
+            183,
+            503,
+            810,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            679,
+            825,
+            750
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/708d5c105fedaef0c7c34a2f4de88b1dbe12f0dca729614572c37f7f4b7b8487.jpg",
+        "table_caption": [
+            "Table 3: NLP results, F1 scores "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Task</td><td>train with square loss (%)</td><td>train with cross-entropy (%)</td><td>square loss w/ same epochs as CE (%)</td></tr><tr><td>BERT</td><td>MRPC</td><td>88.1</td><td>86.7</td><td>88.0</td></tr><tr><td>(Devlin et al., 2018)</td><td>QQP</td><td>70.9</td><td>70.7</td><td>70.7</td></tr><tr><td>LSTM+Attention</td><td>MRPC</td><td>80.9</td><td>80.6</td><td>80.7</td></tr><tr><td>(Chen et al.,2017)</td><td>QQP</td><td>62.6</td><td>62.3</td><td>62.6</td></tr><tr><td>LSTM+CNN</td><td>MRPC</td><td>81.0</td><td>78.2</td><td>81.0</td></tr><tr><td>(He &amp; Lin,2016)</td><td>QQP</td><td>60.3</td><td>60.5</td><td>60.3</td></tr></table>",
+        "bbox": [
+            183,
+            767,
+            810,
+            885
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We observe the relative improvements brought by training with the square loss vary with different model architectures, and other than LSTM $\\cdot +$ CNN model on QQP dataset, all architectures trained with the square loss have better/equal accuracy and F1 score. The performance of loss functions also varies with data size, especially for MRPC, which is a relatively small dataset, all model architectures trained with the square loss gives significantly better results than the cross-entropy. ",
+        "bbox": [
+            176,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.2 AUTOMATIC SPEECH RECOGNITION (ASR) EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            162,
+            617,
+            178
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We consider three datasets, TIMIT, WSJ and Librispeech, and all are ASR tasks. For Librispeech, we choose its train-clean-100 as training set, dev-clean and test-clean as validation and test set. We report phone error rate (PER) and character error rate (CER) for TIMIT, word error rate (WER) and CER for both WSJ and Librispeech. A brief description of the datasets used in our ASR experiments is given in Table $4 ^ { 2 }$ . Note that we only alter the training loss of the acoustic model, while keeping the language model and decoding part the same as described in the literature. The acoustic model is a classifier with the dictionary size as the class number. For TIMIT, getting PER and CER needs two different acoustic models, i.e. they are two separate classification tasks, 42-class classification for PER, and 27-class classification for CER. For WSJ, the size of dictionary used for acoustic model is 52. WER and CER of WSJ are calculated with one acoustic model. Hence for WSJ it is a 52-class classification task for both WER and CER. Acoustic model of Librispeech is a 1000-class classifier for both WER and CER, as we use 1000 unigram (Jurafsky, 2000) based dictionary. The results are in Table 5. ",
+        "bbox": [
+            174,
+            189,
+            825,
+            260
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/1e7719ca6f254f2383c8f20ce38d0eec7278b155b3cd78d07f212d1d20c4aed4.jpg",
+        "table_caption": [
+            "Table 4: ASR task statistics and descriptions "
+        ],
+        "table_footnote": [
+            "\\* This is the number of classes used for training the acoustic model. "
+        ],
+        "table_body": "<table><tr><td>Corpus</td><td>Train</td><td>Test</td><td>#classes</td><td>Metric</td><td>Domain</td></tr><tr><td>TIMIT (Garofolo et al., 1993)</td><td>1.15M</td><td>54K</td><td>42 27</td><td>PER CER</td><td>3.2 hours (training set) telephone English</td></tr><tr><td>WSJ (Paul &amp; Baker,1992)</td><td>28.8M</td><td>252K</td><td>52*</td><td>WER CER</td><td>80 hours (training set) read newspapers</td></tr><tr><td>Librispeech (Panayotov et al., 2015)</td><td>36M</td><td>1M</td><td>1000*</td><td>WER CER</td><td>100 hours (training set) audio books</td></tr></table>",
+        "bbox": [
+            187,
+            281,
+            805,
+            383
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            406,
+            825,
+            518
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/46a4a9ec53e0d459400fccefa6668b80ac1303d45ac8078786c1aca05dce5b24.jpg",
+        "table_caption": [
+            "Table 5: ASR results, error rate "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Task</td><td>trainwith square loss (%)</td><td>trainwith cross-entropy (%)</td><td>square loss w/ same epochs as CE (%)</td></tr><tr><td>Attention+CTC</td><td>TIMIT (PER)</td><td>20.8</td><td>20.8</td><td>20.8</td></tr><tr><td>(Kim et al., 2017)</td><td>TIMIT (CER)</td><td>32.5</td><td>33.4</td><td>32.5</td></tr><tr><td>VGG+BLSTMP</td><td>WSJ (WER)</td><td>5.1</td><td>5.3</td><td>5.1</td></tr><tr><td>(Moritz et al., 2019)</td><td>WSJ (CER)</td><td>2.4</td><td>2.5</td><td>2.4</td></tr><tr><td>VGG+BLSTM</td><td>Librispeech (WER)</td><td>9.8</td><td>10.6</td><td>10.3</td></tr><tr><td>(Moritz et al.,2019)</td><td>Librispeech (CER)</td><td>9.7</td><td>10.7</td><td>10.2</td></tr></table>",
+        "bbox": [
+            176,
+            537,
+            821,
+            643
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We see that the square loss performs better (equal for TIMIT PER result) in all of our tasks. It is interesting to observe that the performance advantage of the square loss reported in Table 5 increases with dataset size. In particular, the relative advantage of the square loss $9 . 3 \\%$ relative improvement on CER, and $7 . 5 \\%$ on WER, respectively) is largest for the biggest dataset, Librispeech. On WSJ, using the square loss has ${ \\sim } 4 \\%$ relative improvement on both CER and WER, while the results on TIMIT for the square loss and cross-entropy are very similar. The question of whether this dependence between the data size and the relative advantage of the square loss over cross-entropy is a coincidence or a recurring pattern requires further investigation. ",
+        "bbox": [
+            173,
+            654,
+            825,
+            765
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For TIMIT and WSJ, we observed that training with both the square loss and the cross-entropy need same epochs to converge. The two training protocols for training with the square loss have same performance, and both are comparable/better than training with the cross-entropy. On Librispeech, the square loss needs more epochs, but provides better performance. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            828
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 COMPUTER VISION EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            845,
+            449,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For vision tasks we conduct experiments on MNIST, CIFAR-10 and ImageNet, as in Table 6. ",
+        "bbox": [
+            173,
+            871,
+            781,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/630a704d2e47cced821691ce2583cbffc2ddccc023042942987a91307f2dd4ef.jpg",
+        "table_caption": [
+            "Table 6: Vision task statistics and descriptions "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Corpus</td><td>Train</td><td>[Test</td><td>#classes</td><td>Metric</td><td>Domain</td></tr><tr><td>MNIST (LeCun et al., 1998)</td><td>60K</td><td>10K</td><td>10</td><td>acc.</td><td>28×28</td></tr><tr><td>CIFAR-10 (Krizhevsky&amp; Hinton,2009)</td><td>50K</td><td>10K</td><td>10</td><td>acc.</td><td>32 ×32</td></tr><tr><td>ImageNet (Russakovsky et al., 2015)</td><td>~1.28M</td><td>50K3</td><td>1000</td><td>acc. Top-5 acc.</td><td>224 × 224</td></tr></table>",
+        "bbox": [
+            178,
+            109,
+            820,
+            179
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As in Table 7, on MNIST and CIFAR-10, training with the square loss and the cross-entropy have comparable accuracy. On much larger ImageNet, with ResNet-50 architecture, the accuracy and Top-5 accuracy of using the square loss are comparable with the ones got by using the cross-entropy loss. While with EfficientNet, using the cross-entropy shows better results. The performance of different loss functions varies among different architectures. On MNIST and CIFAR-10, we use exactly the same hyper-parameters well-selected for the cross-entropy loss. For ImageNet, we adjust the learning rate and add a simple rescaling scheme (see Section 5), all other hyper-parameters are the same as for the cross-entropy loss. The performance of using the square loss can improve with more hyper-parameter tuning. ",
+        "bbox": [
+            173,
+            204,
+            825,
+            330
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/57155a62e3ce57fc9fc749c43aa78e0e87e975dc2a3a3195a8be6f0a9ff3fc29.jpg",
+        "table_caption": [
+            "Table 7: Vision results, accuracy "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Task</td><td>train with square loss (%)</td><td>train with cross-entropy (%)</td><td>square loss w/ same epochs as CE(%)</td></tr><tr><td>TCNN (Bai et al.,2018)</td><td>MNIST(acc.)</td><td>97.7</td><td>97.7</td><td>97.7</td></tr><tr><td>W-Resnet (Zagoruyko &amp; Komodakis,2016)</td><td>CIFAR-10 (acc.)</td><td>95.9</td><td>96.3</td><td>95.9</td></tr><tr><td>ResNet-50</td><td>ImageNet (acc.)</td><td>76.2</td><td>76.1</td><td>76.0</td></tr><tr><td>(He et al.,2016)</td><td>ImageNet(Top-5 acc.)</td><td>93.0</td><td>93.0</td><td>92.9</td></tr><tr><td>EfficientNet</td><td>ImageNet (acc.)</td><td>74.6</td><td>77.0</td><td>74.6</td></tr><tr><td>(Tan&amp;Le,2019)</td><td>ImageNet(Top-5 acc.)</td><td>92.7</td><td>93.3</td><td>92.7</td></tr></table>",
+        "bbox": [
+            176,
+            352,
+            821,
+            438
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For all three datasets, training with the square loss converges as fast as training with the crossentropy, and our two experimental protocols for the square loss result in same accuracy performance (except ImageNet with ResNet-50 model). ",
+        "bbox": [
+            173,
+            445,
+            825,
+            487
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 PERFORMANCE ACROSS DIFFERENT INITIALIZATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            508,
+            648,
+            523
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/fd41992afa5473ae7d64be9e560f1759fd79b1f6d3a44b9571dccc7334757a2e.jpg",
+        "image_caption": [
+            "Figure 1: Difference between accuracy (or error rate) between square loss and CE for each initialization. (Square loss acc. - CE acc.) is shown for accuracy, (CE - Square loss) for error rate. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            556,
+            812,
+            834
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the stability of the results with respect to the randomness of model initialization we analyze the results for each random seed initialization. For each random seed, we calculate the difference between the the accuracy (or the error) of networks trained with the square loss and the cross-entropy respectively. We present the results with error bars for one standard deviation in Figure 1. Absolute error and accuracy results for each run and the corresponding standard deviations are given in Appendix F. ",
+        "bbox": [
+            174,
+            104,
+            522,
+            242
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 8 (Libri is short for Librispeech and I-Net is short for ImageNet) shows the standard deviation of test accuracy/error for training with the square loss and cross-entropy. Square loss has smaller variance in 15 out of 20 tasks, which indicates that training with the square loss is less sensitive to the randomness in the training process. ",
+        "bbox": [
+            174,
+            250,
+            522,
+            347
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 OBSERVATIONS DURING TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            368,
+            493,
+            382
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/d55011231aa1bd7644695084a29ed7a142075ac13efb80893bcc8db3f816afcd.jpg",
+        "table_caption": [
+            "Table 8: Standard deviation of test accuracy/error. Smaller number is bolded. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Dataset</td><td>Square loss</td><td>CE</td></tr><tr><td rowspan=\"4\">BERT</td><td>MRPC</td><td>0.484</td><td>0.766</td></tr><tr><td>SST-2</td><td>0.279</td><td>0.173</td></tr><tr><td>QNLI</td><td>0.241</td><td>0.205</td></tr><tr><td>QQP</td><td>0.045</td><td>0.063</td></tr><tr><td rowspan=\"3\">LSTM +Attention</td><td>MRPC</td><td>0.484</td><td>0.786</td></tr><tr><td>QNLI</td><td>0.210</td><td>0.371</td></tr><tr><td>QQP</td><td>0.566</td><td>0.352</td></tr><tr><td rowspan=\"3\">LSTM +CNN</td><td>MRPC</td><td>0.322</td><td>0.383</td></tr><tr><td>QNLI</td><td>0.173</td><td>0.286</td></tr><tr><td>QQP</td><td>0.458</td><td>0.161</td></tr><tr><td rowspan=\"2\">Attention +CTC</td><td>TIMIT (PER)</td><td>0.508</td><td>0.249</td></tr><tr><td>TIMIT (CER)</td><td>0.361</td><td>0.873</td></tr><tr><td>VGG+</td><td>WSJ (WER)</td><td>0.184</td><td>0.249</td></tr><tr><td>BLSTMP</td><td>WSJ (CER)</td><td>0.077</td><td>0.118</td></tr><tr><td>VGG+</td><td>Libri (WER)</td><td>0.126</td><td>0.257</td></tr><tr><td>BLSTM</td><td>Libri (CER)</td><td>0.148</td><td>0.316</td></tr><tr><td>TCNN</td><td>MNIST</td><td>0.161</td><td>0.173</td></tr><tr><td>W-ResNet</td><td>CIFAR-10</td><td>0.184</td><td>0.481</td></tr><tr><td rowspan=\"2\">ResNet-50</td><td>I-Net (Top-1)</td><td>0.032</td><td>0.045</td></tr><tr><td>I-Net (Top-5)</td><td>0.126</td><td>0.045</td></tr><tr><td rowspan=\"2\">EfficientNet</td><td>I-Net (Top-1)</td><td>0.138</td><td>0.122</td></tr><tr><td>I-Net (Top-5)</td><td>0.089</td><td>0.089</td></tr></table>",
+        "bbox": [
+            537,
+            137,
+            821,
+            395
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "There are several interesting observations in terms of   \nthe optimization speed comparing training with the square loss and the cross-entropy loss. We give the experimental observations for the cases when the class number is small, as for our NLP tasks, which are all 2-class classification tasks, and when the class number is relatively large, as for Libripseech and ImageNet (both have 1000 classes). ",
+        "bbox": [
+            174,
+            400,
+            823,
+            467
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/88dedb56f24a859ae4a14e6a8b164e5fe8f3ac71a967026d82629db2d3e1eaf8.jpg",
+        "image_caption": [
+            "Figure 2: Training curves "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            473,
+            812,
+            614
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare the convergence speed in terms of accuracy, and find that for 2-class NLP classification tasks, the training curves of training with the square loss and the cross-entropy are quite similar. Figure 2 (a) gives the accuracy of three model architectures trained with the square loss and the crossentropy along different epochs for QNLI dataset. For all three models, BERT, LSTM $+$ Attention, and LSTM+CNN, using the square loss converges as fast as cross-entropy loss, and achieves better/comparable accuracy to training with the cross-entropy. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            751
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Convergence speed when class number is large When the class number becomes large, as on speech dataset Librispeech and vision dataset ImageNet, training with the square loss may need more epochs to converge. Figure 2 (b) gives the classification accuracy of acoustic model along different epochs, and Figure 2 (c) gives the accuracy (Top-1) and Top-5 accuracy along different training steps of ResNet on ImageNet. Training with the square loss converges slower but reaches similar/better accuracy. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            842
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 IMPLEMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            357,
+            871
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We summarize the key points of implementation in this section. Full details and the exact parameters are given in Appendix B. Two important pieces of the implementation are (1) no softmax for training with the square loss and (2) loss rescaling for datasets with large number of classes. ",
+        "bbox": [
+            176,
+            886,
+            823,
+            929
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "No softmax. The widely accepted pipeline for modern neural classification tasks trained with the crossentropy loss contains the last softmax layer before calculating the loss. When training with the square loss that layer needs to be removed as it appears to impede optimization. ",
+        "bbox": [
+            174,
+            125,
+            522,
+            208
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Loss rescaling mechanism. For datasets with a small number of classes, we do not use any additional mechanisms. For datasets with a large number of output classes $\\geq 4 2$ in our experiments) we employ loss rescaling which helps to accelerate training. Let $( { \\pmb x } , { \\pmb y } )$ denote a single labeled point, where $\\pmb { x } \\in \\mathbb { R } ^ { d }$ is the feature vector, and $\\boldsymbol { y } \\in \\mathbb { R } ^ { C }$ . Here $C$ is the number ",
+        "bbox": [
+            173,
+            215,
+            522,
+            313
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/22d57ebe2d075d1cf8097b30b84c6373182ae596eab237a8df8b278879ab8be2.jpg",
+        "table_caption": [
+            "Table 9: Rescaling parameters "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>#classes</td><td>k</td><td>M</td></tr><tr><td>MRPC</td><td>2</td><td>1</td><td>1</td></tr><tr><td>SST-2</td><td>2</td><td>1</td><td>1</td></tr><tr><td>QNLI</td><td>2</td><td>1</td><td>1</td></tr><tr><td>QQP</td><td>2</td><td>1</td><td>1</td></tr><tr><td>TIMIT (CER)</td><td>27</td><td>1</td><td>1</td></tr><tr><td>TIMIT (WER)</td><td>42</td><td>1</td><td>15</td></tr><tr><td>WSJ</td><td>52</td><td>1</td><td>15</td></tr><tr><td>Librispeech</td><td>1000</td><td>15</td><td>30</td></tr><tr><td>MNIST</td><td>10</td><td></td><td></td></tr><tr><td>CIFAR-10</td><td></td><td>1</td><td>1</td></tr><tr><td>ImageNet</td><td>10 1000</td><td>1 15</td><td>1 30</td></tr></table>",
+        "bbox": [
+            547,
+            131,
+            810,
+            300
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "of output labels and $\\pmb { y } = [ 0 , \\ldots , \\underbrace { 1 } _ { } , 0 , \\ldots , 0 ]$ is the corresponding one-hot encoding vector of the {zc   \nlabel $c$ . We denote our model by $f : \\mathbb { R } ^ { d }  \\mathbb { R } ^ { C }$ . ",
+        "bbox": [
+            171,
+            313,
+            823,
+            357
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The standard square loss for the one-hot encoded label vector can be written (at a single point) as ",
+        "bbox": [
+            171,
+            362,
+            805,
+            377
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ee10d1ed5eb6e9654b342cbd54bc36060e2688d3a366693ba051301aabce8a88.jpg",
+        "text": "$$\nl = \\frac { 1 } { C } \\left( ( f _ { c } ( \\pmb { x } ) - 1 ) ^ { 2 } + \\sum _ { i = 1 , i \\neq c } ^ { C } f _ { i } ( \\pmb { x } ) ^ { 2 } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            378,
+            637,
+            429
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For a large number of classes, we use the rescaled square loss defined by two parameters, $k$ and $M$ , as follows: ",
+        "bbox": [
+            173,
+            438,
+            825,
+            465
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/767124f4de61adbb3436148f87743f4f5ba1b1051d32d847a4e1e8c778dd9175.jpg",
+        "text": "$$\nl _ { s } = \\frac { 1 } { C } \\left( k * ( f _ { c } ( \\pmb { x } ) - M ) ^ { 2 } + \\sum _ { i = 1 , i \\neq c } ^ { C } f _ { i } ( \\pmb { x } ) ^ { 2 } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            460,
+            661,
+            512
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The parameter $k$ rescales the loss value at the true label, while $M$ rescales the one-hot encoding (the one-hot vector is multiplied by $M$ ). Note that when $k = M = 1$ , the rescaled square loss is same as the standard square loss in Eq. 1. The values of $k$ and $M$ for all experiments are given in Table 9. As in (Demirkaya et al., 2020), the parameter $k$ is used to increase the emphasis on the correct class in multiclass classification, and this paper proves how adding $k$ can simplify the optimization landscape. We find that for very large class numbers additional parameter $M$ further improves performance. ",
+        "bbox": [
+            173,
+            518,
+            825,
+            617
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 SUMMARY AND DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            636,
+            442,
+            651
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work we provided an empirical comparison of training with the cross-entropy and square loss functions for classification tasks in a range of datasets and architectures. We observe that the square loss outperforms cross-entropy across the majority of datasets and architectures, sometimes by a significant margin. No additional parameter modification except for adjusting the learning rate was necessary for most datasets. For datasets with a large number of classes (42 or more) we used additional loss rescaling to accelerate training. We note that all models used in our experiments were originally designed and tuned for training with the cross-entropy loss. We conjecture that if the neural architectures were selected and tuned for the square loss, performance would be further improved and no extra loss rescaling parameters would be necessary. Another important observation is that the final softmax layer, commonly used with cross-entropy, needs to be removed during training with the square loss. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            819
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While we could only explore a small sample of modern models and learning tasks, we believe that the scope of our experiments — ten different neural architectures and ten different datasets across three major application domains — is broad enough to be indicative of the wide spectrum of neural models and datasets. Our empirical results suggest amending best practices of deep learning to include training with square loss for classification problems on equal footing with cross-entropy or even as a preferred option. They also suggest that new theoretical analyses and intuitions need to be developed to understand the important question of training loss function selection. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            356,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The authors acknowledge support from NSF (IIS-1815697) and NIH (R01EB022899) and a Google Faculty Research Award. We thank Nvidia for the donation of GPUs and Google for the free access to the cloud TPUs provided by the TFRC program. LH thanks Wuwei Lan for helpful discussions on NLP experiments and Peidong Wang for discussions on ASR experiments. MB thanks his co-authors on (Muthukumar et al., 2020), D. Hsu, V. Multukumar, A. Narang, A. Sahai and V. Subramanian, for insightful discussions related to loss functions and the Simons Institute for the Theory of Computing, where the initial discussions took place. We thank Ryan Rifkin for valuable feedback. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            231
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            252,
+            285,
+            267
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shaojie Bai, J Zico Kolter, and Vladlen Koltun. An empirical evaluation of generic convolutional and recurrent networks for sequence modeling. arXiv preprint arXiv:1803.01271, 2018.   \nGlenn W Brier. Verification of forecasts expressed in terms of probability. Monthly weather review, 78(1):1–3, 1950.   \nQian Chen, Xiaodan Zhu, Zhen-Hua Ling, Si Wei, Hui Jiang, and Diana Inkpen. Enhanced LSTM for natural language inference. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, pp. 1657–1668, 2017.   \nAhmet Demirkaya, Jiasi Chen, and Samet Oymak. Exploring the role of loss functions in multiclass classification. In 2020 54th Annual Conference on Information Sciences and Systems (CISS), pp. 1–5. IEEE, 2020.   \nJacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.   \nWilliam B Dolan and Chris Brockett. Automatically constructing a corpus of sentential paraphrases. In Proceedings of the Third International Workshop on Paraphrasing (IWP2005), 2005.   \nYarin Gal and Zoubin Ghahramani. Dropout as a bayesian approximation: Representing model uncertainty in deep learning. In international conference on machine learning, pp. 1050–1059, 2016.   \nJohn S Garofolo, Lori F Lamel, William M Fisher, Jonathan G Fiscus, and David S Pallett. Darpa timit acoustic-phonetic continous speech corpus cd-rom. nist speech disc 1-1.1. NASA STI/Recon technical report n, 93, 1993.   \nPavel Golik, Patrick Doetsch, and Hermann Ney. Cross-entropy vs. squared error training: a theoretical and experimental comparison. In Interspeech, volume 13, pp. 1756–1760, 2013.   \nIan Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016. http: //www.deeplearningbook.org.   \nFrank E Harrell Jr. Regression modeling strategies: with applications to linear models, logistic and ordinal regression, and survival analysis. Springer, 2015.   \nHua He and Jimmy Lin. Pairwise word interaction modeling with deep neural networks for semantic similarity measurement. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 937–948, 2016.   \nKaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.   \nShankar Iyer, Nikhil Dandekar, and Kornel Csernai. First Quora Dataset Release: Question Pairs. ´ In https://data.quora.com/First-Quora-Dataset-Release-Question-Pairs, 2017.   \nKatarzyna Janocha and Wojciech Marian Czarnecki. On loss functions for deep neural networks in classification. arXiv preprint arXiv:1702.05659, 2017. ",
+        "bbox": [
+            169,
+            271,
+            826,
+            928
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ziwei Ji and Matus Telgarsky. The implicit bias of gradient descent on nonseparable data. In Conference on Learning Theory, pp. 1772–1798, 2019. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Jurafsky. Speech & language processing. Pearson Education India, 2000. ",
+        "bbox": [
+            174,
+            142,
+            687,
+            157
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Suyoun Kim, Takaaki Hori, and Shinji Watanabe. Joint ctc-attention based end-to-end speech recognition using multi-task learning. In 2017 IEEE international conference on acoustics, speech and signal processing (ICASSP), pp. 4835–4839. IEEE, 2017. ",
+        "bbox": [
+            176,
+            166,
+            825,
+            209
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Douglas M Kline and Victor L Berardi. Revisiting squared-error and cross-entropy functions for training neural network classifiers. Neural Computing & Applications, 14(4):310–318, 2005. ",
+        "bbox": [
+            173,
+            218,
+            820,
+            247
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            171,
+            256,
+            821,
+            272
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wuwei Lan and Wei Xu. Neural network models for paraphrase identification, semantic textual similarity, natural language inference, and question answering. In Proceedings of the 27th International Conference on Computational Linguistics, pp. 3890–3902, 2018. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            324
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            174,
+            333,
+            823,
+            363
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sebastien Marcel and Yann Rodriguez. Torchvision the machine-vision package of torch. In ´ Proceedings of the 18th ACM international conference on Multimedia, pp. 1485–1488, 2010. ",
+        "bbox": [
+            174,
+            372,
+            823,
+            401
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Niko Moritz, Takaaki Hori, and Jonathan Le Roux. Triggered attention for end-to-end speech recognition. In ICASSP 2019-2019 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5666–5670. IEEE, 2019. ",
+        "bbox": [
+            173,
+            410,
+            825,
+            454
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vidya Muthukumar, Adhyyan Narang, Vignesh Subramanian, Mikhail Belkin, Daniel Hsu, and Anant Sahai. Classification vs regression in overparameterized regimes: Does the loss function matter?, 2020. ",
+        "bbox": [
+            173,
+            463,
+            823,
+            506
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vassil Panayotov, Guoguo Chen, Daniel Povey, and Sanjeev Khudanpur. Librispeech: an asr corpus based on public domain audio books. In 2015 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5206–5210. IEEE, 2015. ",
+        "bbox": [
+            174,
+            515,
+            823,
+            559
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Douglas B Paul and Janet M Baker. The design for the wall street journal-based csr corpus. In Proceedings of the workshop on Speech and Natural Language, pp. 357–362. Association for Computational Linguistics, 1992. ",
+        "bbox": [
+            176,
+            568,
+            823,
+            609
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Qichao Que and Mikhail Belkin. Back to the future: Radial basis function networks revisited. In Arthur Gretton and Christian C. Robert (eds.), Proceedings of the 19th International Conference on Artificial Intelligence and Statistics, volume 51 of Proceedings of Machine Learning Research, pp. 1375–1383, Cadiz, Spain, 2016. PMLR. ",
+        "bbox": [
+            173,
+            619,
+            825,
+            676
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: $1 0 0 { , } 0 0 0 { + }$ questions for machine comprehension of text. arXiv preprint arXiv:1606.05250, 2016. ",
+        "bbox": [
+            174,
+            685,
+            823,
+            715
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ryan Michael Rifkin. Everything old is new again: a fresh look at historical approaches in machine learning. PhD thesis, MaSSachuSettS InStitute of Technology, 2002. ",
+        "bbox": [
+            173,
+            724,
+            823,
+            753
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li FeiFei. Imagenet large scale visual recognition challenge. International journal of computer vision, 115(3):211–252, 2015. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            819
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arash Sangari and William Sethares. Convergence analysis of two loss functions in soft-max regression. IEEE Transactions on Signal Processing, 64(5):1280–1288, 2015. ",
+        "bbox": [
+            169,
+            829,
+            823,
+            858
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew $\\mathrm { ~ Y ~ N ~ g ~ } _ { }$ and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 conference on empirical methods in natural language processing, pp. 1631–1642, 2013. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Daniel Soudry, Elad Hoffer, Mor Shpigel Nacson, Suriya Gunasekar, and Nathan Srebro. The implicit bias of gradient descent on separable data. The Journal of Machine Learning Research, 19 (1):2822–2878, 2018.   \nMingxing Tan and Quoc V Le. Efficientnet: Rethinking model scaling for convolutional neural networks. arXiv preprint arXiv:1905.11946, 2019.   \nAlex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R Bowman. Glue: A multi-task benchmark and analysis platform for natural language understanding. arXiv preprint arXiv:1804.07461, 2018.   \nShinji Watanabe, Takaaki Hori, Shigeki Karita, Tomoki Hayashi, Jiro Nishitoba, Yuya Unno, Nelson Enrique Yalta Soplin, Jahn Heymann, Matthew Wiesner, Nanxin Chen, Adithya Renduchintala, and Tsubasa Ochiai. Espnet: End-to-end speech processing toolkit. In Interspeech, pp. 2207–2211, 2018. doi: 10.21437/Interspeech.2018-1456. URL http://dx.doi.org/10. 21437/Interspeech.2018-1456.   \nThomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, R’emi Louf, Morgan Funtowicz, and Jamie Brew. Huggingface’s transformers: State-of-the-art natural language processing. ArXiv, abs/1910.03771, 2019.   \nChen Xing, Sercan Arik, Zizhao Zhang, and Tomas Pfister. Distance-based learning from errors for confidence calibration. arXiv preprint arXiv:1912.01730, 2019.   \nSergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.   \nAston Zhang, Zachary C. Lipton, Mu Li, and Alexander J. Smola. Dive into Deep Learning. 2020. https://d2l.ai. ",
+        "bbox": [
+            168,
+            102,
+            825,
+            482
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "APPENDICES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            497,
+            282,
+            513
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A DATASETS AND TASKS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            530,
+            397,
+            546
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Below we provide a summary of datasets used in the experiments. ",
+        "bbox": [
+            174,
+            561,
+            606,
+            577
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "NLP tasks ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            592,
+            248,
+            606
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "• MRPC (Microsoft Research Paraphrase Corpus) (Dolan & Brockett, 2005) is a corpus of sentence pairs extracted from online news sources. Human annotation indicates whether the sentences in the pair are semantically equivalent. We report accuracy and F1 score. SST-2 (The Stanford Sentiment Treebank) (Socher et al., 2013) is a task to determine the sentiment of a given sentence. This corpus contains sentences from movie reviews and their sentiment given by human annotations. We use only sentence-level labels, and predict positive or negative sentiment. QNLI is a converted dataset from the Stanford Question Answering Dataset (Rajpurkar et al., 2016) which consists of question-paragraph pairs. As in (Wang et al., 2018), this task is to predict whether the context sentence selected from the paragraph contains the answer to the question. QQP (Quora Question Pairs dataset) (Iyer et al., 2017) contains question pairs from the question-answering website Quora. Similar to MRPC, this task is to determine whether a pair of questions are semantically equivalent. We report accuracy and F1 score. ",
+        "bbox": [
+            215,
+            617,
+            826,
+            827
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "ASR tasks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            842,
+            248,
+            856
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "• TIMIT (Garofolo et al., 1993) consists of speech from American English speakers, along with the corresponding phonemical and lexical transcription. It is widely used for acousticphonetic classification and ASR tasks. Its training set, validation set and test set are 3.2 hours, 0.15 hours, 0.15 hours long, respectively. ",
+        "bbox": [
+            217,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "• WSJ (Wall Street Journal corpus) (Paul & Baker, 1992) contains read articles from the Wall Street Journal newspaper. Its training, validation and test set are 80 hours, 1.1 hours and 0.7 hours long, respectively. Librispeech (Panayotov et al., 2015) is a large-scale (1000 hours in total) corpus of 16 kHz English speech derived from audiobooks. We choose the subset train-clean-100 (100 hours) as our training data, dev-clean (2.8 hours) as our validation set and test-clean (2.8 hours) as our test set. ",
+        "bbox": [
+            215,
+            103,
+            825,
+            205
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Vision tasks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            222,
+            259,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "• MNIST (LeCun et al., 1998) contains 60, 000 training images and 10, 000 testing $2 8 \\times 2 8$ pixel images of hand-written digits. It is a 10-class image classification task. CIFAR-10 (Krizhevsky & Hinton, 2009) consists of $5 0 , 0 0 0 3 2 \\times 3 2$ pixel training images and $1 0 , 0 0 0 3 2 \\times 3 2$ pixel test images in 10 different classes. It is a balanced dataset with $6 , 0 0 0$ images of each class. ImageNet (Russakovsky et al., 2015) is an image dataset with 1000 classes, and about 1.28 million images as training set. The sizes of its validation and test set are $5 0 , 0 0 0$ and 10, 000, respectively. All images we use are in $2 2 4 \\times 2 2 4$ pixels. ",
+        "bbox": [
+            215,
+            248,
+            825,
+            371
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B HYPER-PARAMETER SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            391,
+            464,
+            406
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We give the implementation toolkits and specific hyper-parameter settings to help reproduce our results, and list the epochs needed for training with the square loss and the cross-entropy (CE) loss. The data processing is following the standard methods. For NLP tasks, it is the same as in (Wang et al., 2018), and for ASR tasks, it is the same as in (Watanabe et al., 2018). For vision tasks, we are following the default ones given in the implementation of the corresponding papers. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            492
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.1 HYPER-PARAMETERS FOR NLP TASKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            508,
+            482,
+            523
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The implementation of BERT is based on the PyTorch toolkit (Wolf et al., 2019). The specific script we run is https://github.com/huggingface/transformers/blob/master/ examples/text-classification/run_glue.py, and we use the bert-base-cased model for fine-tuning. LSTM $+$ Attention and LSTM+CNN are implemented based on the toolkit released by (Lan & Xu, 2018). The specific hyper-parameters used in the experiments are in Table 10. As there are many hyper-parameters, we only list the key ones, and all other parameters are the default in the scripts. ",
+        "bbox": [
+            173,
+            535,
+            825,
+            632
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/f09c0d6fcc5f536df03d362d109b81e921da9b75458b6fc2d4077a8f6657264e.jpg",
+        "table_caption": [
+            "Table 10: Hyper-parameters for NLP tasks "
+        ],
+        "table_footnote": [
+            "\\* The max sequence length equals the max sentence length of the training set. "
+        ],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Model</td><td rowspan=2 colspan=1>Task</td><td rowspan=2 colspan=1>Batchsize</td><td rowspan=2 colspan=1>max_seqlength</td><td rowspan=1 colspan=2>Learning rate w/</td><td rowspan=1 colspan=2>Epochs training w/</td></tr><tr><td rowspan=1 colspan=1>square loss</td><td rowspan=1 colspan=1>CE</td><td rowspan=1 colspan=1>square loss</td><td rowspan=1 colspan=1>CE</td></tr><tr><td rowspan=4 colspan=1>BERT</td><td rowspan=1 colspan=1>MRPC</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>5e-5</td><td rowspan=1 colspan=1>2e-5</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>SST-2</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>2e-5</td><td rowspan=1 colspan=1>2e-5</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>2e-5</td><td rowspan=1 colspan=1>2e-5</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>2e-5</td><td rowspan=1 colspan=1>2e-5</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=3 colspan=1>LSTM+Attention</td><td rowspan=1 colspan=1>MRPC</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>2e-4</td><td rowspan=1 colspan=1>1e-4</td><td rowspan=1 colspan=1>25</td><td rowspan=1 colspan=1>20</td></tr><tr><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>sent_len*</td><td rowspan=1 colspan=1>1e-4</td><td rowspan=1 colspan=1>1e-4</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td></tr><tr><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>120</td><td rowspan=1 colspan=1>1e-4</td><td rowspan=1 colspan=1>1e-4</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>30</td></tr><tr><td rowspan=3 colspan=1>LSTM+CNN</td><td rowspan=1 colspan=1>MRPC</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>2e-4</td><td rowspan=1 colspan=1>1e-4</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td></tr><tr><td rowspan=1 colspan=1>QNLI</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>sent_len*</td><td rowspan=1 colspan=1>8e-5</td><td rowspan=1 colspan=1>1e-4</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td></tr><tr><td rowspan=1 colspan=1>QQP</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>120</td><td rowspan=1 colspan=1>1e-3</td><td rowspan=1 colspan=1>1e-3</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td></tr></table>",
+        "bbox": [
+            173,
+            665,
+            802,
+            835
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.2 HYPER-PARAMETERS FOR ASR TASKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            483,
+            883
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The implementation of ASR tasks is based on the ESPnet (Watanabe et al., 2018) toolkit, and the specific code we use is the run.sh script under the base folder of each task, which is https: ",
+        "bbox": [
+            176,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "//github.com/espnet/espnet/tree/master/egs/?/asr1, where ’?’ can be ’timit’, ’wsj’, and ’librispeech’. The specific hyper-parameters are following the ones in the configuration file of each task, which is under the base folder. We list the files which give the hyper-parameter settings for acoustic model training in Table 11. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/3d5ad5f02eff46cd8d96b1044c335b27225b42a97ac38babf058ac9aef98d99f.jpg",
+        "table_caption": [
+            "Table 11: Hyper-parameters for ASR tasks "
+        ],
+        "table_footnote": [
+            "\\* For WSJ, we use the language model given by https://drive.google.com/ open?id ${ . } =$ 1Az-4H25uwnEFa4lENc-EKiPaWXaijcJp. \\ We set mtlalpha $= 0 . 3$ , batch-size $\\scriptstyle = 3 0$ . ♦ We set elayers $^ { = 4 }$ , as we use 100 hours training data. "
+        ],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Model</td><td rowspan=2 colspan=1>Task</td><td rowspan=2 colspan=1>Hyper-parameters</td><td rowspan=1 colspan=1>Epochs training w/</td><td rowspan=1 colspan=1>ingw/</td></tr><tr><td rowspan=1 colspan=1>square loss</td><td rowspan=1 colspan=1>CE</td></tr><tr><td rowspan=1 colspan=1>Attention+CTC</td><td rowspan=1 colspan=1>TIMIT</td><td rowspan=1 colspan=1>conf/train.yaml</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td></tr><tr><td rowspan=1 colspan=1>VGG+BLSTMP</td><td rowspan=1 colspan=1>WSJ*</td><td rowspan=1 colspan=1>conf/tuning/train_rnn.yaml</td><td rowspan=1 colspan=1>15</td><td rowspan=1 colspan=1>15</td></tr><tr><td rowspan=1 colspan=1>VGG+BLSTM</td><td rowspan=1 colspan=1>Librispeech</td><td rowspan=1 colspan=1>conf/tuning/train_rnn.yaml</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>20</td></tr></table>",
+        "bbox": [
+            209,
+            193,
+            784,
+            268
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.3 HYPER-PARAMETERS FOR VISION TASKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            333,
+            500,
+            348
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The implementation of these models are based on the open source toolkits. For TCNN and EfficientNet, we use the open source implementation given by (Bai et al., 2018) and (Tan & Le, 2019), respectively. For Wide ResNet, we are based on the open source PyTorch implementation https: //github.com/xternalz/WideResNet-pytorch (W-ResNet). For ResNet-50, our experiments are based on the Tensorflow toolkit https://github.com/tensorflow/tpu/ tree/master/models/official/resnet (ResNet) implemented on TPU. The hyperparameter settings for our vision experiments are in Table 12. ",
+        "bbox": [
+            173,
+            359,
+            825,
+            458
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/45075b808dbec9e81e1f366e9fd9f1b3a37cbe9be4f05b6c95a12ad5a57e605c.jpg",
+        "table_caption": [
+            "Table 12: Hyper-parameters for vision tasks "
+        ],
+        "table_footnote": [
+            "\\ We are doing the permuted MNIST task as in Bai et al. (2018). \\* We give the training steps as in the original implementations. "
+        ],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Model</td><td rowspan=2 colspan=1>Task</td><td rowspan=2 colspan=1>Hyper-parameters</td><td rowspan=1 colspan=2>Epochs training w/</td></tr><tr><td rowspan=1 colspan=1>square loss</td><td rowspan=1 colspan=1>CE</td></tr><tr><td rowspan=1 colspan=1>TCNN</td><td rowspan=1 colspan=1>MNIST4</td><td rowspan=1 colspan=1>the default in (Bai et al., 2018)</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td></tr><tr><td rowspan=1 colspan=1>Wide-ResNet</td><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>the default in W-ResNet,except wide-factor=20</td><td rowspan=1 colspan=1>200</td><td rowspan=1 colspan=1>200</td></tr><tr><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>ImageNet</td><td rowspan=1 colspan=1>the default in ResNet,for square loss, learning rate=0.3</td><td rowspan=1 colspan=1>168885*</td><td rowspan=1 colspan=1>112590*</td></tr><tr><td rowspan=1 colspan=1>EfficientNet</td><td rowspan=1 colspan=1>ImageNet</td><td rowspan=1 colspan=1>the default in EfficientNet-BOof (Tan &amp; Le,2019)</td><td rowspan=1 colspan=1>218949*</td><td rowspan=1 colspan=1>218949*</td></tr></table>",
+        "bbox": [
+            196,
+            491,
+            797,
+            621
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C EXPERIMENTAL RESULTS ON VALIDATION AND TRAINING SETS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            676,
+            732,
+            693
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/227861d950af4f4426765c3f7e58c203cf82782526e84693a7c3f188b9bd96f4.jpg",
+        "table_caption": [
+            "Table 13: NLP results on validation set, accuracy "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Task</td><td>train with square loss (%)</td><td>train with cross-entropy (%)</td><td>square loss w/ same epochs as CE (%)</td></tr><tr><td rowspan=\"4\">BERT (Devlin et al., 2018)</td><td>MRPC</td><td>85.3</td><td>85.0</td><td>85.3</td></tr><tr><td>SST-2</td><td>91.2</td><td>91.5</td><td>91.2</td></tr><tr><td>QNLI</td><td>90.8</td><td>90.7</td><td>90.8</td></tr><tr><td>QQP</td><td>90.8</td><td>90.7</td><td>90.6</td></tr><tr><td rowspan=\"2\">LSTM+Attention (Chen et al., 2017)</td><td>MRPC</td><td>76.5</td><td>74.8</td><td>75.3</td></tr><tr><td>QNLI</td><td>79.7</td><td>79.7</td><td>79.7</td></tr><tr><td rowspan=\"3\">LSTM+CNN (He &amp; Lin,2016)</td><td>QQP</td><td>86.0</td><td>85.5</td><td>86.0</td></tr><tr><td>MRPC</td><td>76.0</td><td>73.3</td><td>76.0</td></tr><tr><td>QNLI QQP</td><td>76.8 84.0</td><td>76.8 85.3</td><td>76.8 84.0</td></tr></table>",
+        "bbox": [
+            186,
+            739,
+            810,
+            912
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/3c1486da4a32321536bc3b39e8c92ef228f03f2d1de2fbb628b95e009a8da58e.jpg",
+        "table_caption": [
+            "Table 14: NLP results on validation set, F1 scores "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Task</td><td>train with square loss (%)</td><td>train with cross-entropy (%)</td><td>square loss w/ same epochs as CE (%)</td></tr><tr><td>BERT</td><td>MRPC</td><td>89.5</td><td>89.6</td><td>89.5</td></tr><tr><td>(Devlin et al., 2018)</td><td>QQP</td><td>87.5</td><td>87.4</td><td>87.4</td></tr><tr><td>LSTM+Attention</td><td>MRPC</td><td>83.7</td><td>83.3</td><td>83.5</td></tr><tr><td>(Chen et al., 2017)</td><td>QQP</td><td>82.1</td><td>81.7</td><td>82.1</td></tr><tr><td>LSTM+CNN</td><td>MRPC</td><td>82.6</td><td>81.4</td><td>82.6</td></tr><tr><td>(He &amp; Lin, 2016)</td><td>QQP</td><td>77.4</td><td>80.2</td><td>77.4</td></tr></table>",
+        "bbox": [
+            186,
+            127,
+            812,
+            244
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We report the results for validation set of NLP tasks in Table 13 for accuracy and Table 14 for F1 scores. ",
+        "bbox": [
+            176,
+            266,
+            821,
+            295
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The validation set results of the ASR tasks are in Table 15. ",
+        "bbox": [
+            173,
+            301,
+            557,
+            316
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/b39f528fe9415996bb6d39ee71ece873fcf1fac5cd20642c04bd0ac5dbf688d0.jpg",
+        "table_caption": [
+            "Table 15: ASR results on validation set, error rate "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Task</td><td>train with square loss (%)</td><td>train with cross-entropy (%)</td><td>square loss w/ same epochs as CE (%)</td></tr><tr><td>Attention+CTC</td><td>TIMIT (PER)</td><td>18.1</td><td>18.3</td><td>18.1</td></tr><tr><td>(Kim et al., 2017)</td><td>TIMIT (CER)</td><td>30.4</td><td>31.4</td><td>30.4</td></tr><tr><td>VGG+BLSTMP</td><td>WSJ (WER)</td><td>8.5</td><td>8.8</td><td>8.5</td></tr><tr><td>(Moritz et al., 2019)</td><td>WSJ (CER)</td><td>3.9</td><td>4.0</td><td>3.9</td></tr><tr><td>VGG+BLSTM</td><td>Librispeech (WER)</td><td>9.3</td><td>10.7</td><td>9.9</td></tr><tr><td>(Moritz et al., 2019)</td><td>Librispeech (CER)</td><td>9.4</td><td>11.1</td><td>10.2</td></tr></table>",
+        "bbox": [
+            176,
+            344,
+            820,
+            450
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We report the training result for NLP tasks in Table 16 for accuracy and F1 score in Table 17. The training results for ASR tasks and vision tasks are in Table 18 and Table 19, respectively. ",
+        "bbox": [
+            176,
+            472,
+            826,
+            501
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/ea5f37b3b07714254ab85cf771689fd9361912fe5c44db5ff31c32f13f4138e9.jpg",
+        "table_caption": [
+            "Table 16: NLP results on training and test set, accuracy "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">Task</td><td colspan=\"2\">train with square loss (%)</td><td colspan=\"2\">train with cross-entropy (%)</td><td colspan=\"2\">square loss w/ same epochs as CE (%)</td></tr><tr><td>Train</td><td>Test</td><td>Train</td><td>Test</td><td>Train</td><td>Test</td></tr><tr><td rowspan=\"4\">BERT (Devlin et al., 2018)</td><td>MRPC</td><td>99.7</td><td>83.8</td><td>99.9</td><td>82.1</td><td>99.6</td><td>83.6</td></tr><tr><td>SST-2</td><td>98.6</td><td>94.0</td><td>99.2</td><td>93.9</td><td>98.6</td><td>93.9</td></tr><tr><td>QNLI</td><td>98.0</td><td>90.6</td><td>97.5</td><td>90.6</td><td>98.0</td><td>90.6</td></tr><tr><td>QQP</td><td>96.2</td><td>88.9</td><td>98.0</td><td>88.9</td><td>96.2</td><td>88.8</td></tr><tr><td rowspan=\"3\">LSTM+Attention (Chen et al., 2017)</td><td>MRPC</td><td>94.6</td><td>71.7</td><td>84.9</td><td>70.9</td><td>93.2</td><td>71.5</td></tr><tr><td>QNLI</td><td>87.7</td><td>79.3</td><td>90.8</td><td>79.0</td><td>87.7</td><td>79.3</td></tr><tr><td>QQP</td><td>93.7</td><td>83.4</td><td>91.5</td><td>83.1</td><td>93.7</td><td>83.4</td></tr><tr><td rowspan=\"3\">LSTM+CNN (He &amp; Lin,2016)</td><td>MRPC</td><td>98.3</td><td>73.2</td><td>92.5</td><td>69.4</td><td>98.3</td><td>72.5</td></tr><tr><td>QNLI</td><td>92.8</td><td>76.0</td><td>90.7</td><td>76.0</td><td>92.8</td><td>76.0</td></tr><tr><td>QQP</td><td>91.3</td><td>84.3</td><td>95.7</td><td>84.4</td><td>91.3</td><td>84.3</td></tr></table>",
+        "bbox": [
+            186,
+            539,
+            812,
+            724
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/1669f471fb4113544b9af2a65f85284dcbbb8a170dceab3a0812cadd4030ae40.jpg",
+        "table_caption": [
+            "Table 17: NLP results on training and test set, F1 scores "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">Task</td><td colspan=\"2\">train with square loss (%)</td><td colspan=\"2\">train with cross-entropy (%)</td><td colspan=\"2\">square loss w/ same epochs as CE (%)</td></tr><tr><td>Train</td><td>Test</td><td>Train</td><td>Test</td><td>Train</td><td>Test</td></tr><tr><td>BERT</td><td>MRPC</td><td>99.8</td><td>88.1</td><td>99.9</td><td>86.7</td><td>99.7</td><td>88.0</td></tr><tr><td>(Devlin et al., 2018)</td><td>QQP</td><td>94.5</td><td>70.9</td><td>97.2</td><td>70.7</td><td>94.5</td><td>70.7</td></tr><tr><td>LSTM+Attention (Chen et al., 2017)</td><td>MRPC QQP</td><td>96.1 91.9</td><td>80.9 62.6</td><td>89.5 89.2</td><td>80.6 62.3</td><td>94.7 91.9</td><td>80.7 62.6</td></tr><tr><td>LSTM+CNN</td><td>MRPC</td><td>98.8</td><td>81.0</td><td>94.5</td><td>78.2</td><td>98.8</td><td>81.0</td></tr><tr><td>(He &amp; Lin, 2016)</td><td>QQP</td><td>88.0</td><td>60.3</td><td>94.2</td><td>60.5</td><td>88.0</td><td>60.3</td></tr></table>",
+        "bbox": [
+            186,
+            777,
+            812,
+            909
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/7e6c3df02bf9292bca4ac7005383f6affd0b6f2dbe7839e073bca85bd3c00036.jpg",
+        "table_caption": [
+            "Table 18: ASR results on training and test set, error rate "
+        ],
+        "table_footnote": [
+            "\\* For WSJ and Librispeech, we take $1 0 \\%$ of the training set for the evaluation of the training error rate. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">Task</td><td colspan=\"2\">train with square loss (%)</td><td colspan=\"2\">trainwith cross-entropy (%)</td><td colspan=\"2\">square loss w/ same epochs as CE (%)</td></tr><tr><td>Train</td><td>Test</td><td>Train</td><td>Test</td><td>Train</td><td>Test</td></tr><tr><td>Attention+CTC</td><td>TIMIT (PER)</td><td>0.9</td><td>20.8</td><td>4.8</td><td>20.8</td><td>0.9</td><td>20.8</td></tr><tr><td>(Kim et al.,2017)</td><td>TIMIT (CER)</td><td>4.5</td><td>32.5</td><td>11.6</td><td>33.4</td><td>4.5</td><td>32.5</td></tr><tr><td>VGG+BLSTMP</td><td>WSJ (WER)*</td><td>0.7</td><td>5.1</td><td>0.3</td><td>5.3</td><td>0.7</td><td>5.1</td></tr><tr><td>(Moritz et al., 2019)</td><td>WSJ(CER)*</td><td>0.3</td><td>2.4</td><td>0.1</td><td>2.5</td><td>0.3</td><td>2.4</td></tr><tr><td>VGG+BLSTM</td><td>Librispeech (WER)*</td><td>0.8</td><td>9.8</td><td>0.4</td><td>10.6</td><td>0.8</td><td>10.3</td></tr><tr><td>(Moritz et al., 2019)</td><td>Librispeech (CER)*</td><td>0.6</td><td>9.7</td><td>0.3</td><td>10.7</td><td>0.6</td><td>10.2</td></tr></table>",
+        "bbox": [
+            176,
+            127,
+            820,
+            244
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/5d0b9dd618985b67662a78e4143d49c892ce7676eb524c0dbb413e8538cdea6c.jpg",
+        "table_caption": [
+            "Table 19: Vision results on training and test set, accuracy "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">Task</td><td colspan=\"2\">train with square loss (%)</td><td colspan=\"2\">train with cross-entropy (%)</td><td colspan=\"2\">square loss w/ same epochs as CE(%)</td></tr><tr><td>Train</td><td>Test</td><td>Train</td><td>Test</td><td>Train</td><td>Test</td></tr><tr><td>TCNN (Bai et al., 2018)</td><td>MNIST (acc.)</td><td>98.3</td><td>97.7</td><td>99.5</td><td>97.7</td><td>98.3</td><td>97.7</td></tr><tr><td>W-Resnet (Zagoruyko &amp; Komodakis,2016)</td><td>CIFAR-10 (acc.)</td><td>100.0</td><td>95.9</td><td>100.0</td><td>96.3</td><td>100.0</td><td>95.9</td></tr><tr><td>ResNet-50</td><td>ImageNet (acc.)</td><td>77.7</td><td>76.2</td><td>80.5</td><td>76.1</td><td>77.7</td><td>76.0</td></tr><tr><td>(He et al., 2016)</td><td>ImageNet (Top-5 acc.)</td><td>93.2</td><td>93.0</td><td>93.4</td><td>93.0</td><td>93.2</td><td>92.9</td></tr><tr><td>EfficientNet</td><td>ImageNet (acc.)</td><td>75.1</td><td>74.6</td><td>81.4</td><td>77.0</td><td>75.1</td><td>74.6</td></tr><tr><td>(Tan &amp; Le,2019)</td><td>ImageNet (Top-5 acc.)</td><td>93.0</td><td>92.7</td><td>94.0</td><td>93.3</td><td>93.0</td><td>92.7</td></tr></table>",
+        "bbox": [
+            176,
+            297,
+            821,
+            393
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D OUR RESULTS COMPARED WITH THE ORIGINAL WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            417,
+            656,
+            433
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We list our results for the models trained with the cross-entropy (CE) loss and compare them to the results reported in the literature or the toolkits in Table 20. As we observe, our results are comparable to the original reported results. ",
+        "bbox": [
+            174,
+            448,
+            826,
+            489
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/2f318e1558849ab35f627aca03adbf7812e7af3a7f52910a1838e7a38f3189ad.jpg",
+        "table_caption": [
+            "Table 20: Training with the cross-entropy loss, our results and the reported ones "
+        ],
+        "table_footnote": [
+            "\\* The implementation in (Wolf et al., 2019) is using bert-base-uncased model, we are using bert-base-cased, which will result in a little difference. Also, as they didn’t give test set results, here for BERT, we give the results of validation set. "
+        ],
+        "table_body": "<table><tr><td>Model</td><td>Task</td><td>Our CE result</td><td>CE result in the literature</td></tr><tr><td rowspan=\"4\">BERT*</td><td>MRPC (acc./F1)</td><td>85.0/89.6</td><td>85.29/89.47 (Wolf et al., 2019)</td></tr><tr><td>SST-2 (acc.)</td><td>91.5</td><td>91.97 (Wolf et al.,2019)</td></tr><tr><td>QNLI (acc.)</td><td>90.7</td><td>87.46 (Wolf et al., 2019)</td></tr><tr><td>QQP (acc./F1)</td><td>90.7/87.4</td><td>88.40/84.31 (Wolf et al., 2019)</td></tr><tr><td>LSTM+Attention LSTM+CNN</td><td></td><td></td><td>N/A N/A</td></tr><tr><td rowspan=\"2\">Attention+CTC</td><td>TIMIT (PER)</td><td></td><td></td></tr><tr><td>TIMIT (CER)</td><td>20.7</td><td>20.5 (Watanabe et al.,2018)</td></tr><tr><td rowspan=\"2\">VGG+BLSTMP</td><td></td><td>32.7</td><td>33.7 (Watanabe et al.,2018)</td></tr><tr><td>WSJ (WER)</td><td>5.4</td><td>5.3 (Watanabe et al., 2018)</td></tr><tr><td rowspan=\"2\">VGG+BLSTM</td><td>WSJ (CER)</td><td>2.6</td><td>2.4 (Watanabe et al., 2018)</td></tr><tr><td>Librispeech (WER)</td><td>10.8</td><td>N/A</td></tr><tr><td>TCNN</td><td>Librispeech (CER) MNIST (acc.)</td><td>11.0 98.0</td><td>N/A</td></tr><tr><td>Wide-ResNet</td><td>CIFAR-10 (acc.)</td><td>96.5</td><td>97.2 (Bai et al., 2018)</td></tr><tr><td>ResNet-50</td><td>ImageNet (acc./Top-5 acc.)</td><td>76.1/93.0</td><td>96.11 (Zagoruyko &amp; Komodakis, 2016) 76.0/93.0 (Tan &amp; Le,2019)</td></tr><tr><td>EfficientNet</td><td>ImageNet (acc./Top-5 acc.)</td><td>77.2/93.4</td><td>77.3/93.5 (Tan &amp; Le,2019)</td></tr></table>",
+        "bbox": [
+            176,
+            530,
+            821,
+            747
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The models marked with ’N/A’ in Table 20 do not have comparable results reported in the literature. Specifically, LSTM $+$ Attention and LSTM $+$ CNN models for NLP tasks are implemented based on the toolkit released by (Lan & Xu, 2018), where they did not show results on MRPC and QNLI. The QQP results are not comparable with ours as they were using a different test set, while we are using the standard test set same as in (Wang et al., 2018). The VGG $^ +$ BLSTM model for Librispeech dataset is based on ESPnet toolkit (Watanabe et al., 2018). Due to computational resources limitations, we only use train-clean-100 (100 hours) as training data and 1000 unigram based dictionary for acoustic model training, while they use 1000 hours of training data with at least 2000 unigram dictionary. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "E REGULARIZATION TERMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            421,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We give the regularization term of each task in Table 21. 0 means we didn’t add regularization term. For WSJ, check the details at line 306 of https://github.com/espnet/espnet/blob/ master/espnet/nets/pytorch_backend/rnn/decoders.py. ",
+        "bbox": [
+            174,
+            133,
+            823,
+            176
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/0218767dbe7230788d2686626d975d44cf5db246ae9bfa1e2c2a302d04557bac.jpg",
+        "table_caption": [
+            "Table 21: Regularization term for each task "
+        ],
+        "table_footnote": [
+            "∗ For dropout, 0.0 means have not apply dropout. "
+        ],
+        "table_body": "<table><tr><td>Model</td><td>Task</td><td>dropout*</td><td>batch norm</td><td>Regularization Term</td></tr><tr><td>BERT</td><td>MRPC/SST-2/QNLI/QQP</td><td>0.1</td><td>N</td><td>0</td></tr><tr><td>LSTM+Attention</td><td>MRPC/QNLI/QQP</td><td>0.5</td><td>N</td><td>0</td></tr><tr><td>LSTM+CNN</td><td>MRPC/QNLI/QQP</td><td>0.0</td><td>N</td><td>0</td></tr><tr><td>Attention+CTC</td><td>TIMIT</td><td>0.0</td><td>N</td><td>0</td></tr><tr><td>VGG+BLSTMP</td><td>WSJ</td><td>0.0</td><td>N</td><td>label smoothing based</td></tr><tr><td>VGG+BLSTM</td><td>Librispeech</td><td>0.0</td><td>N</td><td>0</td></tr><tr><td>TCN</td><td>MNIST</td><td>0.05</td><td>N</td><td>0</td></tr><tr><td>Wide-ResNet</td><td>CIFAR-10</td><td>0.0</td><td>N</td><td>0</td></tr><tr><td>ResNet-50</td><td>ImageNet</td><td>0.0</td><td>Y</td><td>10-4 一n 2 ∑i=1</td></tr><tr><td>EfficientNet</td><td>ImageNet</td><td>0.0</td><td>Y</td><td>10-5 n 2 i=</td></tr></table>",
+        "bbox": [
+            178,
+            213,
+            820,
+            371
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "F VARIANCE OF ACCURACY AMONG DIFFERENT RANDOM SEEDS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            424,
+            723,
+            439
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 gives the error bar of 5 runs corresponding to 5 different random seeds, along with the results for each inidividual run. In the left of each subfigure is the result of training with the square loss, while in the right is result of the cross-entropy. As can be seen in Figure 3, using the square loss has better accuray/error rate and smaller variance in NLP and ASR tasks, which indicates that training with the square loss for those classification tasks is statistically better. ",
+        "bbox": [
+            173,
+            454,
+            825,
+            525
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/e7fe6f296bc8becee021a4cfccdc5faa4859627edae09fbd4bae5d6f54a8fb85.jpg",
+        "image_caption": [
+            "Accuracy among results of 5 random seeds ",
+            "Accuracy among results of 5 random seeds ",
+            "Figure 3: Accuracy/error rate variance of results among 5 random seeds "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            320,
+            816,
+            691
+        ],
+        "page_idx": 16
+    }
+]