Add files using upload-large-folder tool

parse/train/8dqEeFuhgMG/8dqEeFuhgMG.md

@@ -0,0 +1,271 @@
+# Class-Incremental Learning via Dual Augmentation
+
+Fei Zhu1,2, Zhen Cheng1,2, Xu-Yao Zhang1,2∗, Cheng-Lin Liu1,2,3 1NLPR, Institute of Automation, Chinese Academy of Sciences, Beijing 100190, China 2University of Chinese Academy of Sciences, Beijing, 100049, China 3Center for Excellence of Brain Science and Intelligence Technology, CAS {zhufei2018, chengzhen2019}@ia.ac.cn, {xyz, liucl}@nlpr.ia.ac.cn
+
+# Abstract
+
+Deep learning systems typically suffer from catastrophic forgetting of past knowledge when acquiring new skills continually. In this paper, we emphasize two dilemmas, representation bias and classifier bias in class-incremental learning, and present a simple and novel approach that employs explicit class augmentation (classAug) and implicit semantic augmentation (semanAug) to address the two biases, respectively. On the one hand, we propose to address the representation bias by learning transferable and diverse representations. Specifically, we investigate the feature representations in incremental learning based on spectral analysis and present a simple technique called classAug, to let the model see more classes during training for learning representations transferable across classes. On the other hand, to overcome the classifier bias, semanAug implicitly involves the simultaneous generating of an infinite number of instances of old classes in the deep feature space, which poses tighter constraints to maintain the decision boundary of previously learned classes. Without storing any old samples, our method can perform comparably with representative data replay based approaches.
+
+# 1 Introduction
+
+Deep neural networks (DNNs) have enabled great success in many machine learning tasks, based on stationary, large-scale, computationally expensive, and memory-intensive training data [1, 2, 3]. Yet the need of the ability to acquire sequential experience in dynamic and open environments [4, 5, 6] poses a serious challenge to modern deep learning systems, which only perform well on homogenized, balanced, and shuffled data [7]. Typically, DNNs suffer from drastic performance degradation of previously learned tasks after learning new knowledge, which is a well-documented phenomenon, known as catastrophic forgetting [8, 9, 10]. Recently, incremental learning (IL), also referred to as lifelong learning or continual learning, has received extensive attention [11, 12, 13, 14] to enable DNNs to preserve and extend knowledge continually.
+
+Many earlier studies focus on task-incremental learning, which uses separate output layers for different tasks, and needs the task identity for inference [11, 15, 16]. In this work, we consider a more realistic and challenging setting of class-incremental learning (Class-IL), where the model only has access to data of new classes at each stage and needs to learn a unified classifier that can classify all seen classes [13, 17, 18]. Unfortunately, the learning paradigm of Class-IL will lead to two problems: representation bias and classifier bias, as shown in Figure 1. First, for representation learning, if the feature extractor is fixed after learning old classes, the learned representations could be preserved, but suffer from the lack of transferability for new classes; on the contrary, if we update the feature extractor on new classes, the updated representations would be no longer suitable for old classes. Consequently, the old and new classes would be easily overlapped in the deep feature space. We denote this dilemma as the representation bias. Second, to distinguish new classes from old classes, the training loss is typically calculated on all classes. Without old training data, the class weights of old classes would be ill-updated and mismatched with the updated representation space. We denote this dilemma as the classifier bias. In this work, we investigate the learning of representation and classifier in incremental learning and propose a simple and effective dual augmentation framework to overcome these two biases in Class-IL without storing and replaying training data of old classes.
+
+![](images/56c1745bf29cb30faff0510f63ad52cd36cf90119927dafc9626d55d5e972832.jpg)  
+Figure 1: Two inherent problems in Class-IL: representation bias and classifier bias.
+
+Learning Representation for Incremental Learning. Existing works typically regularize network parameters explicitly [11, 15, 16] or implicitly [12] to reduce the representation shift when learning new classes. In this paper, instead of asking how to keep previously learned representations unchanged, we investigate the following question:
+
+What properties of learned representations could facilitate incremental learning? We hypothesize that learning transferable and diverse representations is an important requirement for incremental learning. Intuitively, with such representations, it could be easier to find a model to perform well on all tasks and improve both plasticity and stability, since different tasks would be closer in the parameters space. From a spectral analysis viewpoint, we investigate which components of feature representations are more transferable and less forgettable in the incremental learning process. It is found that spectral components with large eigenvalues are less forgettable. Furthermore, we exploit this finding to propose a simple technique named classAug, which can enlarge the spectral components to introduce more diverse and transferable representations for incremental learning.
+
+Learning Classifier for Incremental Learning. Recently, several works were proposed to alleviate the classifier bias in data replay based methods [18, 19, 20]. However, in non-exemplar based (i.e., without storing and replaying old data) Class-IL setting, the classifier bias is more serious and the above methods can not be directly used. A straightforward way is storing instances of old classes in the deep feature space. However, this strategy is undesirable due to the limited memory resource and scalability. This work delves into the classifier learning for Class-IL and proposes an implicit semantic augmentation (semanAug) approach to generate an infinite number of instances of old classes in the deep feature space by leveraging the distribution information. SemanAug is inspired by MCF [21] and ISDA [22], which have performed semantic augmentation for linear models and DNNs, respectively. However, both our way to leverage semantic augmentation and the motivation fundamentally differ from them [21, 22].
+
+Contributions. (i) We provide new insights into the representation learning in incremental learning by analyzing the structural characteristics of the learned embedding space via spectral decomposition and find that spectral components with large eigenvalues are less forgettable and carry more transferable features. Based on this observation, we propose a simple and effective method of classAug to learn better embedding space for incremental learning. (ii) For classifier learning in incremental learning, we propose semanAug which implicitly involves simultaneous generating an infinite number of instances of old classes in the deep feature space to maintain the decision boundary of previously learned classes. (iii) Extensive experiments on benchmark datasets demonstrate the superior performance of our dual augmentation framework for the challenging scenario of Class-IL.
+
+# 2 Related Work
+
+Incremental Learning. Diverse approaches have been proposed for incremental learning of DNNs. They can be roughly divided into three categories: regularization based, data replay based, and architecture based approaches. Regularization based methods focus on weight regularization by estimating and preventing the important network weights from changing [11, 15, 16]. The difference among those methods is the way to compute the importance of the parameters. However, it is hard to design a reasonable metric to measure the importance of parameters, and it is known that regularization strategies show poor performance in Class-IL scenario [23, 24]. Data replay based methods address both the representation bias and classifier bias straightforwardly by storing a fraction of old data to jointly train the model with current data. With stored real samples, some works [17, 13, 25] use a distillation loss to prevent forgetting, while others [26, 27, 28] develop gradient-based regularization to make more efficient use of the rehearsal data. To avoid storing real data, another line of works generates pseudo-samples of all previous classes for replay using deep generative models [29, 30, 31, 32]. Nevertheless, storing real data is undesirable for resource-limited or privacy and safety concerning scenarios. Moreover, training big generative models for complex datasets is inefficient. Architecture based methods dynamically extend the network structure during the course of incremental learning [33, 34, 35, 36]. However, growing architecture is unfeasible for large numbers of tasks, and those methods are often impractical for Class-IL.
+
+Data Augmentation. Literature is rich on data augmentation for improving the generalization of DNNs. Classical strategies commonly synthesize “positive” new samples in a way that is consistent with the underlying data distribution of the original dataset [3]. Recent works show that label mixing based methods such as Mixup [37] and Cutmix [38] can greatly improve the generalization of DNNs. In complement to the input space augmentations mentioned above, some works have explored feature space augmentations which augment the learned representations in deep embedding space to enhance classifier performance. The intuition behind those works is that certain directions in the deep feature space correspond to meaningful semantic transformations [39, 40]. For instance, deep feature interpolation [40] leverages simple interpolations in the embedding space to achieve semantic augmentation. A recently proposed ISDA [22] performs semantic augmentation by estimating and leveraging the category-wise distribution of deep representations in an online manner. Despite the simplicity, ISDA shows its effectiveness in semi-supervised learning [22], contrastive learning [41], domain adaptation [42] and long-tailed recognition [43].
+
+# 3 Dual Augmentation Framework for Class-Incremental Learning
+
+We first formalize the problem of Class-IL, and then introduce the proposed classAug for representation learning and semanAug for classifier learning, respectively. Finally, we present the dual augmentation framework for Class-IL by combing the two augmentations.
+
+Problem Definition. Typically, a Class-IL problem involves the sequential learning of $\tau$ tasks that consist of disjoint classes sets, and the model has to classify all seen classes at any given point in training. At incremental step $t \in \{ 1 , . . . , T \}$ , $( \pmb { x } , y ) \in \mathcal { D } _ { t }$ denotes a training sample, where $_ { \textbf { \em x } }$ is an sample in the input space $\mathcal { X }$ and $\boldsymbol { y } \in \mathcal { C } _ { t }$ is its corresponding label. $\mathcal { C } _ { t }$ is the class set of task $t$ . To facilitate analysis, we represent the DNN based model with two components: a feature extractor and a unified classifier. Specifically, the feature extractor $f _ { \pmb \theta } : \mathcal { X }  \mathcal { Z }$ , parameterized by $\pmb \theta$ , maps the input $_ { \textbf { \em x } }$ into a feature vector $z \doteq f _ { \pmb \theta } ( \pmb x ) \in \mathbb R ^ { d }$ in the deep feature space $\mathcal { Z }$ ; the unified classifier $g _ { \varphi } : \dot { \mathcal { Z } }  \mathbb { R } ^ { \mathcal { C } _ { 1 : t } }$ , parameterized by $\varphi$ , produces a probability distribution $g _ { \varphi } ( z )$ as the prediction for $_ { \textbf { \em x } }$ . Denote the overall parameters by $\Theta = ( \theta , \varphi )$ .
+
+The general objective is to correctly classify test examples from all seen classes [44]. The key challenge of Class- $\mathrm { . I L }$ is that data from previous tasks are assumed to be unavailable, which means that the best configuration of the model for all seen tasks must be sought by minimizing the predefined loss function $\mathcal { L }$ (e.g., cross-entropy) on current data $\mathcal { D } _ { t }$ :
+
+$$
+\underset { \theta , \varphi } { \mathrm { a r g m i n } } \ \mathbb { E } _ { ( \pmb { x } , \pmb { y } ) \sim \mathcal { D } _ { t } } [ \mathcal { L } ( g _ { \varphi } ( f _ { \theta } ( \pmb { x } ) ) , \pmb { y } ) ] .
+$$
+
+A widely used strategy to preserve old knowledge is knowledge distillation [45], which typically matches the current model with previous model response to current training data using the teacherstudent framework [12, 13, 19].
+
+# 3.1 Learning Representation with Class Augmentation
+
+As we focus on non-exemplar based Class-IL, we intentionally avoid storing training samples of old classes. To maintain the generalizability of the learned representations for old classes, existing methods typically restrain the feature extractor from changing [11, 15, 16, 12]. However, this would lead to a trade-off between the plasticity and stability [5], and it would be hard to perform long-step incremental learning. Our high-level idea is to learn transferable and diverse representations to bridge the old and new classes in a better feature space. To delve into this problem, we want to answer two questions: (1) Which part of feature representations tends to be forgotten in incremental learning? (2) How to facilitate the representation learning for incremental learning?
+
+# 3.1.1 Analyzing Forgetting via Spectral Decomposition
+
+In what follows, we explore which part of feature representations tends to be forgotten and may not be transferable across different tasks in incremental learning. To this end, we propose to quantify the sensitivity of the model to different directions in the deep feature space by measuring the similarity of the space before and after learning new tasks.
+
+Formally, given a feature extractor $f _ { \pmb { \theta } , o l d }$ trained on dataset $\mathcal { D } _ { o l d } = \{ ( x _ { i } , y _ { i } ) \} _ { i = 1 } ^ { n }$ . A new dataset $\mathcal { D } _ { n e w }$ that contains disjoint classes with $\mathcal { D } _ { o l d }$ is used to update $f _ { \pmb { \theta } , o l d }$ , and the updated feature extractor is denoted as $f _ { \pmb { \theta } , n e w }$ . For the samples in $\mathcal { D } _ { o l d }$ , we can get two groups of deep features mapped by $f _ { \pmb { \theta } , o l d }$ and $f _ { \pmb { \theta } , n e w }$ , respectively. Using eigenvalue decomposition, we could respectively decompose the features mapped by original feature extractor (i.e., $f _ { \pmb \theta , o l d } ( \pmb x _ { i } ) )$ as well as the features mapped by updated feature extractor (i.e., $f _ { \pmb { \theta } , n e w } ( \pmb { x } _ { i } ) )$ to different directions as following:
+
+$$
+\frac { 1 } { n } \sum _ { i = 1 } ^ { n } f _ { \pmb { \theta } } ( \pmb { x } _ { i } ) f _ { \pmb { \theta } } ( \pmb { x } _ { i } ) ^ { \mathrm { T } } = \sum _ { j = 1 } ^ { d } \pmb { u } _ { j } \lambda _ { j } \pmb { u } _ { j } ^ { \mathrm { T } } ,
+$$
+
+where $\lambda _ { j }$ represents the eigenvalue with index $j$ and $\mathbf { \Delta } \mathbf { \em u } _ { j }$ is its eigenvector. $d$ is the dimensionality of the feature space. Through spectral factorization in Eq. (2), we can represent the original and new representations with two groups of eigenvectors: $\{ \pmb { u } _ { o l d , 1 } , . . . , \pmb { u } _ { o l d , d } \}$ and $\{ { \pmb u } _ { n e w , 1 } , . . . , { \pmb u } _ { n e w , d } \}$ .
+
+Next, we investigate the forgetting or transferability of each direction. Shonkwiler [46] introduced the principal angles [47] to measure the similarity of two subspaces. However, it is unreasonable to treat all eigenvectors equally to calculate the principal angles, regardless of their relative eigenvalues. Inspired by [48], we use corresponding angles, denoted by $\psi$ , to explore the distance between two subspaces in incremental learning:
+
+Definition 1 (Corresponding Angle) Given two groups of eigenvectors: $\{ \pmb { u } _ { o l d , 1 } , . . . , \pmb { u } _ { o l d , d } \}$ and $\{ { \pmb u } _ { n e w , 1 } , . . . , { \pmb u } _ { n e w , d } \}$ , corresponding angle represents the angle between two eigenvectors corresponding to the same eigenvalue value index. The cosine value of the corresponding angle is:
+
+$$
+\cos ( \psi _ { j } ) = \frac { \langle { \pmb u } _ { o l d , j } , { \pmb u } _ { n e w , j } \rangle } { \| { \pmb u } _ { o l d , j } \| \cdot \| { \pmb u } _ { n e w , j } \| } ,
+$$
+
+where $\mathbf { \Delta } \pmb { u } _ { o l d , j }$ is the $j$ -th eigenvectors with the $j$ -th largest eigenvalue in the old feature space, and similarly for $\mathbf { \Delta } \mathbf { u } _ { n e w , j }$ . Note that $\| \pmb { u } _ { o l d , j } \| = 1$ and $\| \boldsymbol { u } _ { n e w , j } \| = 1$ . For $\mathrm { I L }$ , the meaning of “preserve old knowledge” refers to maintain the previously learned decision boundary among classes. At representation level, for an old class, the shape (i.e., covariance) of the distributions should not be changed too much. If an eigenvector direction only changes slightly after updating the feature extractor, the corresponding angle is small, and vice versa. Intuitively, the corresponding angle could capture the representation shift between the old and updated feature extractor during incremental learning, and reflect the forgetting along certain directions in the deep feature space.
+
+Based on the metric defined above, we explore the forgetting of different directions in Class-IL. We use LwF-MC [12, 13] as baseline method and train a ResNet-18 [1] on CIFAR-100 [49] using SGD in a 2-step manner. Concretely, the model is first trained on the first 50 classes and then updated on the other 50 classes. Figure 2 (a) shows the absolute cosine values of corresponding angles between the old and new eigenvectors. We can observe that eigenvectors with larger eigenvalues produce larger similarity (small corresponding angles), which indicates those directions are more transferable and less forgettable across different tasks. On the contrary, the eigenvectors with small eigenvalues prefer to move after updating the model on new tasks, and could be regarded as forgettable directions.
+
+Transferable and Diverse Representations. As demonstrated above, the directions with larger eigenvalues transfer better and suffer less forgetting. This thought-provoking observation indicates that our learned representations should have the following properties: (1) Transferability: the eigenvalues of those several significant directions should be enlarged to transfer across tasks (or classes). (2) Diversity: the number of the directions with significant eigenvalues should be increased. Note that those properties are different from that in the common single-task learning scenario. Actually, reducing the number of directions with significant variance has been seen as a form of feature compression [51], which is linked to generalization by information theory [52, 53]. However, the usual concepts of generalization may not entirely be appropriate for IL, since standard learning only aims to learn compact representations within training classes without considering new class generalizability. In IL, those less discriminative directions for the current task could capture useful representations for future tasks. A recent paper [54] has shown that strong compressed representations can actually hurt the generalization ability in the deep metric learning setting. Therefore, to reduce forgetting and enhance the transferability of the representations, it is important to enlarge the eigenvalues and increase the number of eigenvectors with significant variance.
+
+![](images/a847d226ee3580ebc04448949af3e1e4cf495144dc2eb03ca315145529a0457e.jpg)  
+Figure 2: (a) Absolute cosine values of corresponding angles. (b) Distribution of eigenvalues for baseline, Mixup [37], LS [50], and our classAug training based models.
+
+# 3.1.2 Learning Representations via Class Augmentation
+
+We now exploit our above analysis to propose a simple method for representation learning in ClassIL. Our key idea is to learn transferable and diverse representations by learning more classes at each incremental stage $t$ . To do so, a direct way is to introduce real classes from other datasets as auxiliary. However, it is unrealistic to always have access to other real classes, and which datasets should be used remains unknown. Therefore, we propose class augmentation (classAug) to augment the original classes by synthesizing auxiliary classes based on $\mathcal { D } _ { t }$ . Concretely, inspired
+
+by Mixup [37], classAug randomly interpolates two samples $\scriptstyle { \mathbf { { \mathit { x } } } } _ { a }$ and $\mathbf { \delta } _ { \mathbf { \mathcal { X } } _ { b } }$ from two different classes $a$ and $b$ to generate a new sample $\pmb { x } _ { a b } ^ { \mathrm { n e w } }$ representing a new class:
+
+$$
+\begin{array} { r } { \pmb { x } _ { a b } ^ { \mathrm { n e w } } = \lambda \pmb { x } _ { a } + ( 1 - \lambda ) \pmb { x } _ { b } , } \end{array}
+$$
+
+where $\lambda$ is a random number of interpolation coefficient. For a $k$ -class problem, we can generate $k ( k - 1 ) / 2$ new classes using the above method, which can be further merged to $m$ auxiliary classes. As a result, the original $k$ -class
+
+![](images/181a0feee2667ad82c937d1822282b688f49bffd084261e8171eb8fe738b4674.jpg)  
+Figure 3: Illustration of classAug.
+
+problem in the current task is extended to a $( k + m )$ -class problem. Moreover, we restrict the $\lambda$ to be sampled from the interval of [0.4, 0.6], to reduce the overlap between the augmented and original classes. At the end of each $\mathrm { I L }$ stage, the augmented class nodes in the classifier would be removed.
+
+Discussion. The proposed classAug is related to Mixup [37] which applies random interpolation on a pair of training samples and the respective one-hot labels. However, the interpolated samples in Mixup are near original data, and the number of classes is not changed, but in our method, it is increased. By learning to classify more classes in each stage $t$ , the model could learn more transferable and diverse representations. Figure 2 (b) displays and compares the eigenvalues 2 of representations learned with different methods on the first 50 classes of CIFAR-100. It is obvious that the proposed classAug can enhance the value of eigenvalues significantly, and produce more directions with significant variance compared with other methods. On the contrary, Mixup and Label-Smoothing (LS) [50] lead to significantly smaller eigenvalues for the several top eigenvectors, which represent more compact representations. Indeed, the compression effect of soft-label based methods has also been demonstrated in [51, 50]. As shown in Section 4.3, classAug can improve the performance of Class-IL significantly, while Mixup and LS have negative effect in our experiments.
+
+# 3.2 Learning Classifier with Semantic Augmentation
+
+As demonstrated in Section 1, classifier bias is another problem in Class-IL. When learning new classes, the previously learned decision boundary would suffer from catastrophic distortion and thus the test samples from old classes could be easily mapped to wrong classes. To overcome this issue, we propose semantic augmentation (semanAug), which leverages the distribution information (i.e., class mean and covariance) of old classes to regularize the learning of the classifier. Formally, for each old class $k \in \{ 1 , . . . , \mathcal { C } _ { o l d } \}$ , we can generate $M$ instances in the deep feature space from its distribution, i.e., $\widetilde { z } _ { k } \backsim \mathcal { N } ( \mu _ { k } , \gamma \Sigma _ { k } )$ , in which $\gamma$ is a non-negative coefficient. Then the generated einstances of old classes and real instances of new classes in the deep feature space can be jointly fed to the classifier for minimizing cross-entropy loss:
+
+$$
+\mathcal { L } _ { t } = \frac { 1 } { n _ { t } } \sum _ { i = 1 } ^ { n _ { t } } - \log \left( \frac { e ^ { \varphi _ { y _ { i } } ^ { \mathrm { T } } z _ { i } + b _ { y _ { i } } } } { \sum _ { c = 1 } ^ { \mathcal { C } _ { a l l } } e ^ { \varphi _ { c } ^ { \mathrm { T } } z _ { i } + b _ { c } } } \right) + \frac { 1 } { \mathcal { C } _ { o l l } } \sum _ { k = 1 } ^ { \mathcal { C } _ { o l l } } \frac { 1 } { M } \sum _ { m = 1 } ^ { M } - \log \left( \frac { e ^ { \varphi _ { k } ^ { \mathrm { T } } \widetilde z _ { k , m } + b _ { k } } } { \sum _ { c = 1 } ^ { \mathcal { C } _ { a l l } } e ^ { \varphi _ { c } ^ { \mathrm { T } } \widetilde z _ { k , m } + b _ { c } } } \right) _ { \textstyle ; }
+$$
+
+$\mathcal { L } _ { t , o l d }$ {z: loss on generated features of old classes
+
+where $n _ { t }$ is the number of training samples in current task dataset $\mathcal { D } _ { t }$ , $\mathcal { C } _ { o l d }$ is the number of total old classes upon stage $t$ , and $\mathcal { C } _ { a l l } = \mathcal { C } _ { o l d } + \mathcal { C } _ { t }$ is the number of all seen classes at stage $t$ . $\varphi =$ $\left[ \varphi _ { 1 } , . . . , \varphi _ { \mathcal { C } _ { a l l } } \right] ^ { \mathrm { T } } \in \mathcal { R } ^ { \check { C } _ { a l l } \times d }$ and $b = [ b _ { 1 } , . . . , b _ { { \mathcal { C } } _ { a l l } } ] ^ { \mathrm { T } } \in { \mathcal { R } } ^ { { \mathcal { C } } _ { a l l } }$ are the weight matrix and bias vector of the last fully connected layer, respectively.
+
+In Class-IL, the second term in Eq. (5), $\mathcal { L } _ { t , o l d }$ , is computationally inefficient when $M$ and $\mathcal { C } _ { o l d }$ are large. In the following, we present an easy-to-compute way to implicitly generate infinite instances in the deep feature space for old classes.
+
+Upper bound of $\mathcal { L } _ { t , o l d }$ . Concretely, in the case of $M \to \infty$ , the second term in Eq. (5):
+
+$$
+\begin{array} { l } { \displaystyle \mathcal { L } _ { t , o l d } = \frac { 1 } { \tilde { C } _ { o l d } } \sum _ { k = 1 } ^ { \tilde { C } _ { o l d } } \mathbb { E } _ { \Xi _ { k } } \left[ - \log \left( \frac { e ^ { \varphi _ { k } ^ { \mathsf { T } } \bar { \varepsilon } _ { k } + b _ { k } } } { \sum _ { c = 1 } ^ { \tilde { C } _ { o l d } } e ^ { \varphi _ { c } ^ { \Gamma } \bar { \varepsilon } _ { k } + b _ { c } } } \right) \right] = \frac { 1 } { \tilde { C } _ { o l d } } \sum _ { k = 1 } ^ { \tilde { C } _ { o l d } } \mathbb { E } _ { \Xi _ { k } } \left[ \log \left( \displaystyle \sum _ { c = 1 } ^ { \tilde { C } _ { o l l } } e ^ { ( \varphi _ { c } ^ { \mathsf { T } } - \varphi _ { k } ^ { \mathsf { T } } ) \bar { \varepsilon } _ { k } + ( b _ { c } - b _ { k } ) } \right) \right] } \\ { \displaystyle \leqslant \frac { 1 } { \tilde { C } _ { o l d } } \sum _ { k = 1 } ^ { \infty } \log \left( \mathbb { E } _ { \Xi _ { k } } \left[ \displaystyle \sum _ { c = 1 } ^ { \tilde { C } _ { o l l } } e ^ { ( \varphi _ { c } ^ { \mathsf { T } } - \varphi _ { k } ^ { \mathsf { T } } ) \bar { \varepsilon } _ { k } + ( b _ { c } - b _ { k } ) } \right] \right) } \\ { \displaystyle = \frac { 1 } { \tilde { C } _ { o l d } } \sum _ { k = 1 } ^ { \infty } \log \left( \displaystyle \sum _ { c = 1 } ^ { \tilde { C } _ { o l l } } e ^ { \nu _ { c , k } ^ { \mathsf { T } } \mu _ { k } + ( b _ { c } - b _ { k } ) + \frac { \gamma } { 2 } \upsilon _ { c , k } ^ { \mathsf { T } } \Sigma _ { k } \nu _ { c , k } } \right) . } \end{array}
+$$
+
+In above equation, ${ \pmb v } _ { c , k } = { \pmb \varphi } _ { c } - { \pmb \varphi } _ { k }$ . The inequality is based on Jensen’s inequality $\mathbb { E } [ \log ( X ) ] \leqslant$ $\log \mathbb { E } [ X ]$ , and the last equality is obtained by using the moment-generating function $\mathbb { E } [ e ^ { t X } ] =$ $e ^ { t \mu + { \frac { 1 } { 2 } } \sigma ^ { 2 } t ^ { 2 } }$ , $X \backsim \mathcal N ( \mu , \sigma ^ { 2 } )$ , due to the fact that $( \varphi _ { c } - \varphi _ { k } ) \widetilde { z } _ { k } + ( b _ { c } - b _ { k } )$ is a Gaussian random evariable. As can be seen, Eq. (6) is an upper bound of original $\mathcal { L } _ { t , o l d }$ , which provides an elegant and much efficient way to implicitly generate infinite instances in the deep feature space for old classes. The $\mathcal { L } _ { t , o l d }$ in Eq. (6) can be write in the common cross-entropy loss form:
+
+$$
+\mathcal { L } _ { t , s e m a n A u g } \triangleq \mathcal { L } _ { t , o l d } = \frac { 1 } { \mathcal { C } _ { o l d } } \sum _ { k = 1 } ^ { \mathcal { C } _ { o l d } } - \log \left( \frac { e ^ { \varphi _ { k } ^ { \mathrm { T } } \mu _ { k } + b _ { k } } } { \sum _ { c = 1 } ^ { \mathcal { C } _ { a l l } } e ^ { \varphi _ { c } ^ { \mathrm { T } } \mu _ { k } + b _ { c } + \frac { \gamma } { 2 } \upsilon _ { c , k } ^ { \mathrm { T } } \Sigma _ { k } v _ { c , k } } } \right) .
+$$
+
+Intuitively, $\mathcal { L } _ { t , o l d }$ implicitly performs semantic transformations for $\mu _ { k }$ based on $\Sigma _ { k }$ . To maintain the decision boundary, $\gamma$ should be smaller if the distribution of a class is near the decision boundary; instead, $\gamma$ should be bigger if the distance is relatively far. We set $\gamma = 2$ in our experiments. In addition, we can observe that when $\gamma = 0$ , only the class means are used for knowledge retention.
+
+Discussion. (1) Although the derivation of the upper bound in Eq. (6) is similar with ISDA [22], both our motivation and the way to leverage semanAug are different from ISDA. When learning new classes, we only apply semanAug for the class mean of each old class based on the memorized distribution information. While ISDA applies semanAug on all the training samples to improve generalization in standard supervised learning. In addition, a crucial step in ISDA is to estimate the mean and covariance matrix of each class in an online manner. Differently, semanAug is naturally suitable for Class-IL, since the distribution of old classes can be estimated with all training samples at the end of each learning stage. (2) Using previous class statistics for $\mathrm { I L }$ has also been explored in IL2M [55]. However, our method differs from IL2M in both the statistics information and the way to leverage them. First, The class statistics in IL2M is the prediction score of the classifier, while ours is the class distribution statistics in the deep feature space. Second, IL2M uses the class statistics to calibrate the prediction of a continual learner in a post-processing manner, while our method leverage the statistics to automatically learn a balanced classifier.
+
+![](images/922d60182efbe7fdd1ddad11c8566318e3d0dd841048f2bc6908945a1fbce749.jpg)  
+Figure 4: Illustration of our dual augmentation framework (IL2A) for Class-IL. On the one hand, the training samples of new classes at current task are augmented via the proposed classAug. On the other hand, the distributions of old classes are retained by semanAug in the deep feature space.
+
+# 3.3 The Dual Augmentation Learning Framework
+
+With classAug for representation bias and semanAug for classifier bias, Figure 4 describes the learning process of the dual augmentation framework (IL2A). We also use the well-known knowledge distillation (KD) [19] for two reasons. Firstly, classAug and KD are complementary and focus on different aspect of learning representation. Secondly, KD can reduce the change of feature extractor, which is crucial for semanAug because it implicitly generate instances in the deep feature space from old distribution. The total learning objective at each stage $t$ is as following:
+
+$$
+\mathcal { L } _ { t } = \mathcal { L } _ { t , n e w } + \alpha \mathcal { L } _ { t , s e m a n A u g } + \beta \mathcal { L } _ { t , k d } ,
+$$
+
+where $\alpha$ and $\beta$ are two hyper-parameters. $\mathcal { L } _ { t , n e w }$ and $\mathcal { L } _ { t , s e m a n A u g }$ are shown in Eq. (5) and Eq. (7), respectively. $\begin{array} { r } { \mathcal { L } _ { t , k d } = \frac { 1 } { n _ { t } } \sum _ { i = 1 } ^ { n _ { t } } \| f _ { \pmb { \theta } _ { t - 1 } } ( \pmb { x } _ { i } ) - f _ { \pmb { \theta } _ { t } } ( \pmb { x } _ { i } ) \| } \end{array}$ . Note that $\mathcal { L } _ { t , n e w }$ and $\mathcal { L } _ { t , s e m a n A u g }$ are applied to both the original and synthesized samples. Algorithm 1 presents the pseudo code of IL2A.
+
+# 4 Experiments
+
+# 4.1 Evaluation Protocol
+
+Datasets. We perform our experiments on CIFAR-100 [49] and Tiny-ImageNet [56]. A common setting is to train the model on half of classes for first task, and equal classes in the remaining incremental steps. Based on this, we split the CIFAR-100 dataset in different settings: $5 0 + 5 \times 1 0$ , $5 0 + \pm 0 \times 5$ , $4 0 + 2 { \pmb \theta } \times 3$ . For instance, $5 0 +$ $I { \pmb \theta } \times 5$ represents that the first task contains 50 classes and there are 5 classes for the following 10 tasks. Similarly, the settings for Tiny-ImageNet are $1 0 0 + { \pmb { 5 } } \times 2 0 $ , $1 0 0 +$ $1 0 \times 1 0$ and $1 0 0 { + } 2 { \pm } 5$ . Intuitively, more classes in each tasks requires the model to learn a harder problem for each task, while increasing the length of the task sequence challenges the model’s retention.
+
+# Algorithm 1: IL2A: Dual augmentation algorithm
+
+Randomly initialize $\Theta ^ { 0 } = \{ \theta ^ { 0 } , \varphi ^ { 0 } \}$ ; ${ \mathcal { S } } ^ { 0 } = \emptyset$ ;   
+foreach incremental stage $t \in \{ 1 , . . . , T \}$ do Input: model $\Theta ^ { t - 1 }$ , data $\mathcal { D } _ { t } = \{ ( x _ { i } , y _ { i } ) \} _ { i = 1 } ^ { n _ { t } }$ ; Output: model $\Theta ^ { t }$ ; $\Theta ^ { t } \bar {  } \Theta ^ { t - 1 }$ ; $\mathcal { D } _ { t , a u g } = \{ ( \boldsymbol { x } _ { i } ^ { \prime } , \boldsymbol { y } _ { i } ^ { \prime } ) \} _ { i = 1 } ^ { n _ { t } ^ { \prime } }$ via classAug; add class nodes for augmented classes; if $t = 1$ then train $\Theta ^ { t }$ by minimizing $\mathcal { L } ( g _ { \varphi } ( f _ { \theta } ( \pmb { x } ^ { \prime } ) ) , y ^ { \prime } )$ ; else train $\Theta ^ { t }$ by minimizing Eq. (8); $s \gets$ compute $\{ \mu , \Sigma \}$ for each class in $\mathcal { D } _ { t }$ ; $S ^ { t } \gets S ^ { t - 1 } \cup s ;$ remove augmented class nodes in classifier;
+
+![](images/fcb711f00b1081d5d60c7b70d9e62c8c544bcc4686b010481488154f5665887a.jpg)  
+Figure 5: Results of top-1 accuracy on CIFAR-100 and Tiny-ImageNet under different settings. Solid lines present methods that do not store old exemplars, dashed lines present data replay based methods.
+
+in each experiment. All models are trained using Adam [57] optimizer with an initial learning rate of 0.001 for 100 epochs with the mini-batch size of 64. The learning rate is reduced by a factor of 10 at 45 and 90 epochs. We use the same hyper-parameter value for all experiments. Specifically, we set $\alpha = 1 0$ and $\beta = 1 0$ in Eq. (8). The number of augmented classes (i.e. The number of augmented classes (i.e., $m$ ) depends on the number of (original) classes at current incremental step. Taking CIFAR-100 as an example, the $m$ is 45 for 5 phases setting where each incremental step has 10 classes; and $m$ is 10 for 10 phases setting where each incremental step has 5 classes. At the end of each incremental stage, we evaluate the model on all seen classes after removing the class nodes of the $m$ augmented classes in the classifier. Our code is available at https://github.com/Impression2805/IL2A.
+
+Comparison Methods. Our method (IL2A) does not store any old samples for replay when learning new classes. Therefore, we first compare IL2A with several non-exemplar based approaches: MAS [16], LwF-MC [13], MUC [58], LwM [59]. In addition, we also compare with several exemplar based methods such as iCaRL [13], EEIL [18] and LUCIR [19]. Specifically, for the data replay based methods, we follow [13, 19] to store 20 samples for each class using ‘herd’ selection technique [13]. We report the average top-1 accuracy of all previously seen classes up to each incremental step t. For iCaRL, we respectively report its results of CNN predictions and nearest-mean-of-exemplars classification, denoted as iCaRL-CNN and iCaRL-NME.
+
+# 4.2 Experimental Results
+
+Main Results. Comparative results are shown in Figure 5. Firstly, we observe that our method performs much better than non-exemplar based methods such as LwF-MC and MUC in the trend of accuracy curve under different settings. Particularly, the gap appears unbridgeable in the long-step Class-IL setting, e.g., 10 phases and 20 phases. This suggests that only constraining old parameters does not suffice to prevent forgetting. We argue that this is partly due to the unaddressed classifier bias. When compared to representative data replay based methods such as iCaRL, EEIL and LUCIR, our method remarkably shows strong performance without storing old samples.
+
+The success of our method can contribute to the proposed classAug and semanAug. Specifically, classAug is applied to new classes of current task, which enables the model to learn more transferable and diverse representations for future classes and in turn, reduces the forgetting of old parameters when learning new classes. While semanAug is applied to old classes of previous tasks, which leverage the valuable distribution information of old classes to learn a unified classifier to connect the classes from different tasks to each other.
+
+Ablation Study. To evaluate the effect of each component in IL2A, we perform the ablation study and show the results of 10 phases setting (CIFAR-100) in Table 1. Specifically, the baseline denotes the method that does not generate pseudo-instance using semanAug, but only replays the class-mean of each old class when training new classes. By doing so, we aim to validate the effectiveness of semanAug compared with only replaying class-mean. In summary, we can observe that: (1) Baseline improves the performance of KD significantly. (2) SemanAug improves the performance of baseline from $3 4 . 7 1 \%$ to $4 2 . 0 9 \%$ . Those results indicate the effect of the distribution information for maintaining old knowledge in Class-IL. (3) ClassAug also has remarkably effect on baseline, and (4) the performance can be further improved by combing with semanAug, which indicates that those two modules are complementary. Similar results are observed in other settings of CIFAR-100 and Tiny-ImageNet datasets. (5) As for the computational complexity, classAug involves input level sample mixing and the augmented samples are fed to feature extractor. Differently, semanAug performs implicit old instance generation in the deep feature space. Therefore, semanAug is cheaper compared with classAug from the computation perspective.
+
+Table 1: The effect of each component in IL2A.   
+
+<table><tr><td rowspan=1 colspan=1>Method\Incremental stage</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>Final</td></tr><tr><td rowspan=4 colspan=1>Knowledge Distillationbaseline+ semanAug+ classAug</td><td rowspan=1 colspan=1>78.78</td><td rowspan=1 colspan=1>30.18</td><td rowspan=1 colspan=1>20.71</td><td rowspan=1 colspan=1>14.61</td><td rowspan=1 colspan=1>11.87</td><td rowspan=1 colspan=1>8.80</td><td rowspan=1 colspan=1>7.70</td><td rowspan=1 colspan=1>7.23</td><td rowspan=1 colspan=1>7.10</td><td rowspan=1 colspan=1>6.05</td><td rowspan=1 colspan=1>6.04</td></tr><tr><td rowspan=1 colspan=1>78.86</td><td rowspan=1 colspan=1>62.85</td><td rowspan=1 colspan=1>56.96</td><td rowspan=1 colspan=1>54.66</td><td rowspan=1 colspan=1>51.72</td><td rowspan=1 colspan=1>47.33</td><td rowspan=1 colspan=1>43.61</td><td rowspan=1 colspan=1>40.12</td><td rowspan=1 colspan=1>40.76</td><td rowspan=1 colspan=1>36.55</td><td rowspan=1 colspan=1>34.71</td></tr><tr><td rowspan=1 colspan=1>79.16</td><td rowspan=1 colspan=1>69.14</td><td rowspan=1 colspan=1>60.68</td><td rowspan=1 colspan=1>58.18</td><td rowspan=1 colspan=1>54.77</td><td rowspan=1 colspan=1>50.89</td><td rowspan=1 colspan=1>48.45</td><td rowspan=1 colspan=1>46.29</td><td rowspan=1 colspan=1>46.97</td><td rowspan=1 colspan=1>44.38</td><td rowspan=1 colspan=1>42.09</td></tr><tr><td rowspan=1 colspan=1>79.72</td><td rowspan=1 colspan=1>68.30</td><td rowspan=1 colspan=1>64.15</td><td rowspan=1 colspan=1>60.15</td><td rowspan=1 colspan=1>56.21</td><td rowspan=1 colspan=1>52.61</td><td rowspan=1 colspan=1>51.48</td><td rowspan=1 colspan=1>46.48</td><td rowspan=1 colspan=1>46.36</td><td rowspan=1 colspan=1>43.63</td><td rowspan=1 colspan=1>41.56</td></tr><tr><td rowspan=1 colspan=1> + classAug + semanAug</td><td rowspan=1 colspan=1>81.08</td><td rowspan=1 colspan=1>74.54</td><td rowspan=1 colspan=1>66.28</td><td rowspan=1 colspan=1>63.89</td><td rowspan=1 colspan=1>58.80</td><td rowspan=1 colspan=1>54.97</td><td rowspan=1 colspan=1>51.32</td><td rowspan=1 colspan=1>48.64</td><td rowspan=1 colspan=1>49.74</td><td rowspan=1 colspan=1>47.05</td><td rowspan=1 colspan=1>45.07</td></tr></table>
+
+# 4.3 Further Analysis
+
+ClassAug Improves both Plasticity and Stability in Class-IL. To analyze the effectiveness of classAug more concretely, we explore how it affects the new tasks accuracy (↑) and average forgetting (↓) (CIFAR-100, 10 phases setting). Average forgetting [60] is defined to estimate the forgetting of previous tasks. The forgetting measure $\bar { f } _ { k } ^ { i }$ of the $i$ -th task after training $k$ -th task is defined as $f _ { k } ^ { i } = \operatorname* { m a x } _ { t \in 1 , \ldots , k - 1 } ( a _ { t , i } - a _ { k , i } ) , \forall i < k$ , in which $a _ { m , n }$ is the accuracy of task $n$ after training task $m$ .
+
+The average forgetting measure $F _ { k }$ is then defined as 1k−1 Pk−1i=1 f ik. Intuitively, new task accuracy can be viewed as the plasticity of the incremental learner and the average forgetting can be viewed as the stability of the incremental learner. Figure 6 (a) and (b) report the results, from which we see that classAug simultaneously improves the new task accuracy and reduces the average forgetting. Specifically, the significant improvement on new task accuracy implies that the model training with classAug is a good initialization for the following tasks. Consequently, classAug is effective to improve the trade-off between plasticity and stability of a continual learner.
+
+![](images/74b1ad39f42f5a89b574e88fa477fed16c9e657e8a74d5d3be13dc2d0e41c807.jpg)  
+Figure 6: (a, b) ClassAug can simultaneously improve the new task accuracy and reduce the average forgetting. (c) Compared with classAug, Mixup and LS have negative effect for Class-IL.
+
+Compare ClassAug with Other Regularizers. We compare the proposed classAug with Mixup and LS in Figure 6 (c), where the baseline (with semanAug) represents our IL2A without using classAug. As can be seen, Mixup and LS have negative effect on the final accuracy. This phenomenon could be interpreted based on the analysis in Section 3.1.1 and Figure 2 (b). Specifically, those regularizers result in more compressed representations, damaging the transferability of the representations. Besides, the label smoothing strategy also affects the weights of old classes in the classifier, thus increasing the classifier bias. Similar results have also been reported in [61].
+
+Discussion of Covariance Matrix. In our main experiments, we use the original covariance matrix for semanAug. However, storing the original covariance matrix might be inefficient when the matrix dimension is large. An alternative way is to only store the elements on the diagonal, which could greatly reduce the cost of memory. Figure 7 also reports the results of using the diagonal covariance matrix. Under different settings, using the original covariance matrix is slightly better than the diagonal form. This is reasonable because the original covariance matrix stores more distribution information of old classes. However, using the diagonal covariance matrix would be more memory-efficient in practice.
+
+Table 2: OOD detection results. $\uparrow$ indicates higher is better.   
+
+<table><tr><td rowspan="2">0OD</td><td colspan="3">AUROC↑</td><td colspan="3">AUPR-In↑</td><td colspan="3">AUPR-Out个</td></tr><tr><td>baseline</td><td>Mixup</td><td>classAug</td><td>baseline</td><td>Mixup</td><td>classAug</td><td>baseline</td><td>Mixup</td><td>classAug</td></tr><tr><td>MNIST</td><td>87.02</td><td>92.46</td><td>94.99</td><td>79.89</td><td>89.00</td><td>93.05</td><td>92.26</td><td>95.48</td><td>97.20</td></tr><tr><td>Fashion-MNIST</td><td>90.28</td><td>93.37</td><td>94.40</td><td>86.18</td><td>89.11</td><td>92.43</td><td>94.26</td><td>96.19</td><td>96.78</td></tr><tr><td>LSUN</td><td>88.50</td><td>88.80</td><td>93.90</td><td>83.48</td><td>74.71</td><td>91.08</td><td>92.92</td><td>94.09</td><td>96.73</td></tr><tr><td>Tiny-ImageNet</td><td>88.49</td><td>84.96</td><td>93.92</td><td>83.84</td><td>64.02</td><td>91.77</td><td>92.70</td><td>92.19</td><td>96.55</td></tr><tr><td>Mean</td><td>88.57</td><td>89.90</td><td>94.30</td><td>83.35</td><td>79.21</td><td>92.08</td><td>93.04</td><td>94.49</td><td>96.81</td></tr></table>
+
+ClassAug Improves Confidence Reliability. During continuous use of a machine learning system in open-world applications, there are mainly three key steps [62]. The first step is out-of-distribution (OOD) detection [63], which requires the system to detect unknown samples from novel classes. The second step is to label the collected unknown samples by humans or automatic algorithms [64]. Finally, the system must scale and adapt incrementally to learn the novel classes, which is the Class-IL problem studied in this paper. Recently studies found that DNNs are overconfident for their predictions [63, 65], lacking the ability to detect samples from unknown classes. In real-world applications, we expect a continual learner has good OOD detection ability.
+
+![](images/b0ee6625c379c219150f00397ededed20299312038543491731ac6f129574fbc.jpg)  
+Figure 7: Original v.s. diagonal covariance matrix. CIFAR-100.
+
+We explore the OOD detection ability of the proposed classAug. Concretely, we train a ResNet-18 on CIFAR-10, and the test samples from CIFAR-10 are in-distribution. For OOD examples, we test on MNIST [66], Fashion-MNIST [67], LSUN (resized) [68] and Tiny-ImageNet (resized). As shown in Table 2, classAug noticeably improves the OOD detection performance of baseline [63] on commonly used metrics such as AUROC, AUPR-In and AUPR-Out [63]. By recognizing synthetic samples, DNNs could learn more robust and transferable representations which could be generalized to OOD samples. Moreover, as shown in Table 2, Mixup sometimes damages the performance of OOD detection, which further demonstrates the superiority of classAug.
+
+# 5 Conclusion
+
+In this paper, we propose a simple and effective dual augmentation framework to address the representation bias and classifier bias in Class-IL. We first investigate the transferability (or forgetting) of representations via spectral decomposition, which motivates us to propose classAug that can learn transferable, diverse and less compact representations for IL. Furthermore, we propose to use semanAug to implicitly generate infinite instances of old classes in the deep feature space during jointly learning of the unified classifier. Experiments show that our method could achieve remarkable performance compared with state-of-the-art Class-IL methods. Future works will consider the dual augmentation framework for more challenging scenarios like Class-IL with distribution shift and OOD data, few-shot Class-IL, and federated incremental learning.
+
+# Acknowledgements
+
+This work has been supported by the National Key Research and Development Program under Grant No. 2018AAA0100400, the National Natural Science Foundation of China (NSFC) grants U20A20223, 61633021, 62076236, 61721004, the Key Research Program of Frontier Sciences of CAS under Grant ZDBS-LY-7004, and the Youth Innovation Promotion Association of CAS under Grant 2019141.
+
+References   
+[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pages 770–778, 2016. 1, 4, 7   
+[2] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, pages 248–255, 2009. 1   
+[3] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NeurIPS, pages 1097–1105, 2012. 1, 3   
+[4] Gregory Ditzler, Manuel Roveri, Cesare Alippi, and Robi Polikar. Learning in nonstationary environments: A survey. IEEE Computational Intelligence Magazine, 10(4):12–25, 2015. 1   
+[5] German I Parisi, Ronald Kemker, Jose L Part, Christopher Kanan, and Stefan Wermter. Continual lifelong learning with neural networks: A review. Neural Networks, 113:54–71, 2019. 1, 4   
+[6] Matthias Delange, Rahaf Aljundi, Marc Masana, Sarah Parisot, Xu Jia, Ales Leonardis, Greg Slabaugh, and Tinne Tuytelaars. A continual learning survey: Defying forgetting in classification tasks. IEEE Trans. Pattern Anal. Mach. Intell., 2021. 1   
+[7] Raia Hadsell, Dushyant Rao, Andrei A Rusu, and Razvan Pascanu. Embracing change: Continual learning in deep neural networks. Trends in Cognitive Sciences, 2020. 1   
+[8] Ian J. Goodfellow, M. Mirza, Xia Da, Aaron C. Courville, and Yoshua Bengio. An empirical investigation of catastrophic forgeting in gradient-based neural networks. CoRR, 2014. 1   
+[9] M. McCloskey and N. J. Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. Psychology of Learning and Motivation, pages 109–165, 1989. 1   
+[10] Robert M French. Interactive tandem networks and the sequential learning problem. Citeseer. 1   
+[11] J. Kirkpatrick, Razvan Pascanu, Neil C. Rabinowitz, J. Veness, G. Desjardins, Andrei A. Rusu, K. Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, Demis Hassabis, C. Clopath, D. Kumaran, and Raia Hadsell. Overcoming catastrophic forgetting in neural networks. Proceedings of the National Academy of Sciences, pages 3521 – 3526, 2017. 1, 2, 3, 4   
+[12] Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE Trans. Pattern Anal. Mach. Intell., pages 2935–2947, 2018. 1, 2, 3, 4   
+[13] Sylvestre-Alvise Rebuffi, A. Kolesnikov, Georg Sperl, and Christoph H. Lampert. icarl: Incremental classifier and representation learning. In CVPR, pages 5533–5542, 2017. 1, 3, 4, 8   
+[14] Ameya Prabhu, Philip HS Torr, and Puneet K Dokania. Gdumb: A simple approach that questions our progress in continual learning. In ECCV, pages 524–540, 2020. 1   
+[15] Friedemann Zenke, Ben Poole, and Surya Ganguli. Continual learning through synaptic intelligence. In ICML, pages 3987–3995, 2017. 1, 2, 3, 4   
+[16] Rahaf Aljundi, Francesca Babiloni, Mohamed Elhoseiny, Marcus Rohrbach, and Tinne Tuytelaars. Memory aware synapses: Learning what (not) to forget. In ECCV, pages 139–154, 2018. 1, 2, 3, 4, 8   
+[17] Y. Wu, Yan-Jia Chen, Lijuan Wang, Yuancheng Ye, Zicheng Liu, Yandong Guo, and Yun Fu. Large scale incremental learning. In CVPR, pages 374–382, 2019. 1, 3   
+[18] Francisco M Castro, Manuel J Marín-Jiménez, Nicolás Guil, Cordelia Schmid, and Karteek Alahari. End-to-end incremental learning. In ECCV, pages 233–248, 2018. 1, 2, 8   
+[19] Saihui Hou, Xinyu Pan, Chen Change Loy, Zilei Wang, and D. Lin. Learning a unified classifier incrementally via rebalancing. In CVPR, pages 831–839, 2019. 2, 3, 7, 8   
+[20] Bowen Zhao, Xi Xiao, Guojun Gan, Bin Zhang, and Shu-Tao Xia. Maintaining discrimination and fairness in class incremental learning. In CVPR, pages 13205–13214, 2020. 2   
+[21] Laurens Maaten, Minmin Chen, Stephen Tyree, and Kilian Weinberger. Learning with marginalized corrupted features. In ICML, pages 410–418, 2013. 2   
+[22] Yulin Wang, Gao Huang, Shiji Song, Xuran Pan, Yitong Xia, and Cheng Wu. Regularizing deep networks with semantic data augmentation. IEEE Trans. Pattern Anal. Mach. Intell., 2021. 2, 3, 6   
+[23] Yen-Chang Hsu, Yen-Cheng Liu, Anita Ramasamy, and Zsolt Kira. Re-evaluating continual learning scenarios: A categorization and case for strong baselines. arXiv preprint arXiv:1810.12488, 2018. 3   
+[24] Gido M Van de Ven and Andreas S Tolias. Three scenarios for continual learning. arXiv preprint arXiv:1904.07734, 2019. 3   
+[25] Arthur Douillard, Matthieu Cord, Charles Ollion, Thomas Robert, and Eduardo Valle. Podnet: Pooled outputs distillation for small-tasks incremental learning. In ECCV, pages 86–102, 2020. 3   
+[26] Matthew Riemer, Ignacio Cases, Robert Ajemian, Miao Liu, Irina Rish, Yuhai Tu, and Gerald Tesauro. Learning to learn without forgetting by maximizing transfer and minimizing interference. In ICLR, 2018. 3   
+[27] David Lopez-Paz and Marc’Aurelio Ranzato. Gradient episodic memory for continual learning. In NeurIPS, 2017. 3   
+[28] Arslan Chaudhry, Marc’Aurelio Ranzato, Marcus Rohrbach, and Mohamed Elhoseiny. Efficient lifelong learning with a-gem. In ICLR, 2019. 3   
+[29] Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. In NeurIPS, pages 2994–3003, 2017. 3   
+[30] Chenshen Wu, L. Herranz, X. Liu, Y. Wang, Joost van de Weijer, and B. Raducanu. Memory replay gans: Learning to generate new categories without forgetting. In NeurIPS, pages 5962–5972, 2018. 3   
+[31] Ye Xiang, Ying Fu, Pan Ji, and Hua Huang. Incremental learning using conditional adversarial networks. In ICCV, pages 6618–6627, 2019. 3   
+[32] Ronald Kemker and Christopher Kanan. Fearnet: Brain-inspired model for incremental learning. In ICLR, 2018. 3   
+[33] Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016. 3   
+[34] Arun Mallya and Svetlana Lazebnik. Packnet: Adding multiple tasks to a single network by iterative pruning. In CVPR, pages 7765–7773, 2018. 3   
+[35] Joan Serra, Didac Suris, Marius Miron, and Alexandros Karatzoglou. Overcoming catastrophic forgetting with hard attention to the task. In ICML, pages 4548–4557, 2018. 3   
+[36] Jaehong Yoon, Eunho Yang, Jeongtae Lee, and Sung Ju Hwang. Lifelong learning with dynamically expandable networks. In ICLR, 2018. 3   
+[37] Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. Mixup: Beyond empirical risk minimization. In ICLR, 2018. 3, 5   
+[38] Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In ICCV, pages 6023–6032, 2019. 3   
+[39] Yoshua Bengio, Grégoire Mesnil, Yann Dauphin, and Salah Rifai. Better mixing via deep representations. In ICML, pages 552–560, 2013. 3   
+[40] Paul Upchurch, Jacob Gardner, Geoff Pleiss, Robert Pless, Noah Snavely, Kavita Bala, and Kilian Weinberger. Deep feature interpolation for image content changes. In CVPR, pages 7064–7073, 2017. 3   
+[41] Qi Cai, Yu Wang, Yingwei Pan, Ting Yao, and Tao Mei. Joint contrastive learning with infinite possibilities. In NeurIPS, 2020. 3   
+[42] Shuang Li, Mixue Xie, Kaixiong Gong, Chi Harold Liu, Yulin Wang, and Wei Li. Transferable semantic augmentation for domain adaptation. arXiv preprint arXiv:2103.12562, 2021. 3   
+[43] Shuang Li, Kaixiong Gong, Chi Harold Liu, Yulin Wang, Feng Qiao, and Xinjing Cheng. Metasaug: Meta semantic augmentation for long-tailed visual recognition. arXiv preprint arXiv:2103.12579, 2021. 3   
+[44] Pietro Buzzega, Matteo Boschini, Angelo Porrello, Davide Abati, and Simone Calderara. Dark experience for general continual learning: a strong, simple baseline. In NeurIPS, 2020. 3, 7   
+[45] Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015. 3   
+[46] Clayton Shonkwiler. Poincaré duality angles for riemannian manifolds with boundary. arXiv preprint arXiv:0909.1967, 2009. 4   
+[47] Jianming Miao and Adi Ben-Israel. On principal angles between subspaces in rn. Linear algebra and its applications, 171:81–98, 1992. 4   
+[48] Xinyang Chen, Sinan Wang, Mingsheng Long, and Jianmin Wang. Transferability vs. discriminability: Batch spectral penalization for adversarial domain adaptation. In ICML, pages 1081–1090, 2019. 4   
+[49] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. Technical report, 2009. 4, 7   
+[50] Rafael Müller, Simon Kornblith, and Geoffrey E. Hinton. When does label smoothing help? In NeurIPS, pages 4696–4705, 2019. 5   
+[51] Vikas Verma, Alex Lamb, Christopher Beckham, Amir Najafi, Ioannis Mitliagkas, David Lopez-Paz, and Yoshua Bengio. Manifold mixup: Better representations by interpolating hidden states. In ICML, pages 6438–6447, 2019. 5   
+[52] Naftali Tishby and Noga Zaslavsky. Deep learning and the information bottleneck principle. In 2015 IEEE Information Theory Workshop (ITW), pages 1–5, 2015. 5   
+[53] Ravid Shwartz-Ziv and Naftali Tishby. Opening the black box of deep neural networks via information. arXiv preprint arXiv:1703.00810, 2017. 5   
+[54] Karsten Roth, Timo Milbich, Samarth Sinha, Prateek Gupta, Björn Ommer, and Joseph Paul Cohen. Revisiting training strategies and generalization performance in deep metric learning. In ICML, 2020. 5   
+[55] Eden Belouadah and Adrian Popescu. Il2m: Class incremental learning with dual memory. In ICCV, pages 583–592, 2019. 6   
+[56] Leon Yao and John Miller. Tiny imagenet classification with convolutional neural networks. CS 231N. 7   
+[57] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015. 8   
+[58] Yu Liu, Sarah Parisot, Gregory G. Slabaugh, Xu Jia, Ales Leonardis, and Tinne Tuytelaars. More classifiers, less forgetting: A generic multi-classifier paradigm for incremental learning. In ECCV, pages 699–716, 2020. 8   
+[59] Prithviraj Dhar, Rajat Vikram Singh, Kuan-Chuan Peng, Ziyan Wu, and Rama Chellappa. Learning without memorizing. In CVPR, pages 5138–5146, 2019. 8   
+[60] Arslan Chaudhry, P. Dokania, Thalaiyasingam Ajanthan, and P. Torr. Riemannian walk for incremental learning: Understanding forgetting and intransigence. In ECCV, pages 532–547, 2018. 9   
+[61] Sudhanshu Mittal, Silvio Galesso, and Thomas Brox. Essentials for class incremental learning. arXiv preprint arXiv:2102.09517, 2021. 9   
+[62] Xu-Yao Zhang, Cheng-Lin Liu, and Ching Y Suen. Towards robust pattern recognition: A review. Proceedings of the IEEE, 108(6):894–922, 2020. 10   
+[63] Dan Hendrycks and Kevin Gimpel. A baseline for detecting misclassified and out-of-distribution examples in neural networks. In ICLR, 2017. 10   
+[64] Kai Han, Sylvestre-Alvise Rebuffi, Sébastien Ehrhardt, Andrea Vedaldi, and Andrew Zisserman. Autonovel: Automatically discovering and learning novel visual categories. IEEE Trans. Pattern Anal. Mach. Intell., 2021. 10   
+[65] Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q Weinberger. On calibration of modern neural networks. In ICML, pages 1321–1330, 2017. 10   
+[66] Yann LeCun and Corinna Cortes. The mnist database of handwritten digits. 2005. 10   
+[67] Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017. 10   
+[68] Fisher Yu, Yinda Zhang, Shuran Song, Ari Seff, and Jianxiong Xiao. Lsun: Construction of a large-scale image dataset using deep learning with humans in the loop. ArXiv, abs/1506.03365, 2015. 10

parse/train/8dqEeFuhgMG/8dqEeFuhgMG_content_list.json

@@ -0,0 +1,1140 @@
+[
+    {
+        "type": "text",
+        "text": "Class-Incremental Learning via Dual Augmentation ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            122,
+            812,
+            148
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Fei Zhu1,2, Zhen Cheng1,2, Xu-Yao Zhang1,2∗, Cheng-Lin Liu1,2,3 1NLPR, Institute of Automation, Chinese Academy of Sciences, Beijing 100190, China 2University of Chinese Academy of Sciences, Beijing, 100049, China 3Center for Excellence of Brain Science and Intelligence Technology, CAS {zhufei2018, chengzhen2019}@ia.ac.cn, {xyz, liucl}@nlpr.ia.ac.cn ",
+        "bbox": [
+            214,
+            199,
+            787,
+            272
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            308,
+            535,
+            324
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning systems typically suffer from catastrophic forgetting of past knowledge when acquiring new skills continually. In this paper, we emphasize two dilemmas, representation bias and classifier bias in class-incremental learning, and present a simple and novel approach that employs explicit class augmentation (classAug) and implicit semantic augmentation (semanAug) to address the two biases, respectively. On the one hand, we propose to address the representation bias by learning transferable and diverse representations. Specifically, we investigate the feature representations in incremental learning based on spectral analysis and present a simple technique called classAug, to let the model see more classes during training for learning representations transferable across classes. On the other hand, to overcome the classifier bias, semanAug implicitly involves the simultaneous generating of an infinite number of instances of old classes in the deep feature space, which poses tighter constraints to maintain the decision boundary of previously learned classes. Without storing any old samples, our method can perform comparably with representative data replay based approaches. ",
+        "bbox": [
+            233,
+            340,
+            766,
+            546
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            574,
+            310,
+            592
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks (DNNs) have enabled great success in many machine learning tasks, based on stationary, large-scale, computationally expensive, and memory-intensive training data [1, 2, 3]. Yet the need of the ability to acquire sequential experience in dynamic and open environments [4, 5, 6] poses a serious challenge to modern deep learning systems, which only perform well on homogenized, balanced, and shuffled data [7]. Typically, DNNs suffer from drastic performance degradation of previously learned tasks after learning new knowledge, which is a well-documented phenomenon, known as catastrophic forgetting [8, 9, 10]. Recently, incremental learning (IL), also referred to as lifelong learning or continual learning, has received extensive attention [11, 12, 13, 14] to enable DNNs to preserve and extend knowledge continually. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            731
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many earlier studies focus on task-incremental learning, which uses separate output layers for different tasks, and needs the task identity for inference [11, 15, 16]. In this work, we consider a more realistic and challenging setting of class-incremental learning (Class-IL), where the model only has access to data of new classes at each stage and needs to learn a unified classifier that can classify all seen classes [13, 17, 18]. Unfortunately, the learning paradigm of Class-IL will lead to two problems: representation bias and classifier bias, as shown in Figure 1. First, for representation learning, if the feature extractor is fixed after learning old classes, the learned representations could be preserved, but suffer from the lack of transferability for new classes; on the contrary, if we update the feature extractor on new classes, the updated representations would be no longer suitable for old classes. Consequently, the old and new classes would be easily overlapped in the deep feature space. We denote this dilemma as the representation bias. Second, to distinguish new classes from old classes, the training loss is typically calculated on all classes. Without old training data, the class weights of old classes would be ill-updated and mismatched with the updated representation space. We denote this dilemma as the classifier bias. In this work, we investigate the learning of representation and classifier in incremental learning and propose a simple and effective dual augmentation framework to overcome these two biases in Class-IL without storing and replaying training data of old classes. ",
+        "bbox": [
+            174,
+            737,
+            825,
+            876
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/56c1745bf29cb30faff0510f63ad52cd36cf90119927dafc9626d55d5e972832.jpg",
+        "image_caption": [
+            "Figure 1: Two inherent problems in Class-IL: representation bias and classifier bias. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            94,
+            820,
+            220
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            260,
+            825,
+            343
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning Representation for Incremental Learning. Existing works typically regularize network parameters explicitly [11, 15, 16] or implicitly [12] to reduce the representation shift when learning new classes. In this paper, instead of asking how to keep previously learned representations unchanged, we investigate the following question: ",
+        "bbox": [
+            174,
+            349,
+            825,
+            405
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "What properties of learned representations could facilitate incremental learning? We hypothesize that learning transferable and diverse representations is an important requirement for incremental learning. Intuitively, with such representations, it could be easier to find a model to perform well on all tasks and improve both plasticity and stability, since different tasks would be closer in the parameters space. From a spectral analysis viewpoint, we investigate which components of feature representations are more transferable and less forgettable in the incremental learning process. It is found that spectral components with large eigenvalues are less forgettable. Furthermore, we exploit this finding to propose a simple technique named classAug, which can enlarge the spectral components to introduce more diverse and transferable representations for incremental learning. ",
+        "bbox": [
+            173,
+            405,
+            825,
+            529
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning Classifier for Incremental Learning. Recently, several works were proposed to alleviate the classifier bias in data replay based methods [18, 19, 20]. However, in non-exemplar based (i.e., without storing and replaying old data) Class-IL setting, the classifier bias is more serious and the above methods can not be directly used. A straightforward way is storing instances of old classes in the deep feature space. However, this strategy is undesirable due to the limited memory resource and scalability. This work delves into the classifier learning for Class-IL and proposes an implicit semantic augmentation (semanAug) approach to generate an infinite number of instances of old classes in the deep feature space by leveraging the distribution information. SemanAug is inspired by MCF [21] and ISDA [22], which have performed semantic augmentation for linear models and DNNs, respectively. However, both our way to leverage semantic augmentation and the motivation fundamentally differ from them [21, 22]. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            688
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions. (i) We provide new insights into the representation learning in incremental learning by analyzing the structural characteristics of the learned embedding space via spectral decomposition and find that spectral components with large eigenvalues are less forgettable and carry more transferable features. Based on this observation, we propose a simple and effective method of classAug to learn better embedding space for incremental learning. (ii) For classifier learning in incremental learning, we propose semanAug which implicitly involves simultaneous generating an infinite number of instances of old classes in the deep feature space to maintain the decision boundary of previously learned classes. (iii) Extensive experiments on benchmark datasets demonstrate the superior performance of our dual augmentation framework for the challenging scenario of Class-IL. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            818
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            837,
+            321,
+            854
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Incremental Learning. Diverse approaches have been proposed for incremental learning of DNNs. They can be roughly divided into three categories: regularization based, data replay based, and architecture based approaches. Regularization based methods focus on weight regularization by estimating and preventing the important network weights from changing [11, 15, 16]. The difference among those methods is the way to compute the importance of the parameters. However, it is hard to design a reasonable metric to measure the importance of parameters, and it is known that regularization strategies show poor performance in Class-IL scenario [23, 24]. Data replay based methods address both the representation bias and classifier bias straightforwardly by storing a fraction of old data to jointly train the model with current data. With stored real samples, some works [17, 13, 25] use a distillation loss to prevent forgetting, while others [26, 27, 28] develop gradient-based regularization to make more efficient use of the rehearsal data. To avoid storing real data, another line of works generates pseudo-samples of all previous classes for replay using deep generative models [29, 30, 31, 32]. Nevertheless, storing real data is undesirable for resource-limited or privacy and safety concerning scenarios. Moreover, training big generative models for complex datasets is inefficient. Architecture based methods dynamically extend the network structure during the course of incremental learning [33, 34, 35, 36]. However, growing architecture is unfeasible for large numbers of tasks, and those methods are often impractical for Class-IL. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            285
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Data Augmentation. Literature is rich on data augmentation for improving the generalization of DNNs. Classical strategies commonly synthesize “positive” new samples in a way that is consistent with the underlying data distribution of the original dataset [3]. Recent works show that label mixing based methods such as Mixup [37] and Cutmix [38] can greatly improve the generalization of DNNs. In complement to the input space augmentations mentioned above, some works have explored feature space augmentations which augment the learned representations in deep embedding space to enhance classifier performance. The intuition behind those works is that certain directions in the deep feature space correspond to meaningful semantic transformations [39, 40]. For instance, deep feature interpolation [40] leverages simple interpolations in the embedding space to achieve semantic augmentation. A recently proposed ISDA [22] performs semantic augmentation by estimating and leveraging the category-wise distribution of deep representations in an online manner. Despite the simplicity, ISDA shows its effectiveness in semi-supervised learning [22], contrastive learning [41], domain adaptation [42] and long-tailed recognition [43]. ",
+        "bbox": [
+            173,
+            291,
+            825,
+            470
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Dual Augmentation Framework for Class-Incremental Learning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            489,
+            741,
+            507
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first formalize the problem of Class-IL, and then introduce the proposed classAug for representation learning and semanAug for classifier learning, respectively. Finally, we present the dual augmentation framework for Class-IL by combing the two augmentations. ",
+        "bbox": [
+            174,
+            522,
+            825,
+            564
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Problem Definition. Typically, a Class-IL problem involves the sequential learning of $\\tau$ tasks that consist of disjoint classes sets, and the model has to classify all seen classes at any given point in training. At incremental step $t \\in \\{ 1 , . . . , T \\}$ , $( \\pmb { x } , y ) \\in \\mathcal { D } _ { t }$ denotes a training sample, where $_ { \\textbf { \\em x } }$ is an sample in the input space $\\mathcal { X }$ and $\\boldsymbol { y } \\in \\mathcal { C } _ { t }$ is its corresponding label. $\\mathcal { C } _ { t }$ is the class set of task $t$ . To facilitate analysis, we represent the DNN based model with two components: a feature extractor and a unified classifier. Specifically, the feature extractor $f _ { \\pmb \\theta } : \\mathcal { X }  \\mathcal { Z }$ , parameterized by $\\pmb \\theta$ , maps the input $_ { \\textbf { \\em x } }$ into a feature vector $z \\doteq f _ { \\pmb \\theta } ( \\pmb x ) \\in \\mathbb R ^ { d }$ in the deep feature space $\\mathcal { Z }$ ; the unified classifier $g _ { \\varphi } : \\dot { \\mathcal { Z } }  \\mathbb { R } ^ { \\mathcal { C } _ { 1 : t } }$ , parameterized by $\\varphi$ , produces a probability distribution $g _ { \\varphi } ( z )$ as the prediction for $_ { \\textbf { \\em x } }$ . Denote the overall parameters by $\\Theta = ( \\theta , \\varphi )$ . ",
+        "bbox": [
+            173,
+            569,
+            825,
+            696
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The general objective is to correctly classify test examples from all seen classes [44]. The key challenge of Class- $\\mathrm { . I L }$ is that data from previous tasks are assumed to be unavailable, which means that the best configuration of the model for all seen tasks must be sought by minimizing the predefined loss function $\\mathcal { L }$ (e.g., cross-entropy) on current data $\\mathcal { D } _ { t }$ : ",
+        "bbox": [
+            173,
+            700,
+            825,
+            757
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a3efe1a443fb9cdc6fb12fff6b8fcaaea984d3fadd80ee6a8dfe8bacbf90d099.jpg",
+        "text": "$$\n\\underset { \\theta , \\varphi } { \\mathrm { a r g m i n } } \\ \\mathbb { E } _ { ( \\pmb { x } , \\pmb { y } ) \\sim \\mathcal { D } _ { t } } [ \\mathcal { L } ( g _ { \\varphi } ( f _ { \\theta } ( \\pmb { x } ) ) , \\pmb { y } ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            763,
+            625,
+            791
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A widely used strategy to preserve old knowledge is knowledge distillation [45], which typically matches the current model with previous model response to current training data using the teacherstudent framework [12, 13, 19]. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            840
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Learning Representation with Class Augmentation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            857,
+            566,
+            872
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As we focus on non-exemplar based Class-IL, we intentionally avoid storing training samples of old classes. To maintain the generalizability of the learned representations for old classes, existing methods typically restrain the feature extractor from changing [11, 15, 16, 12]. However, this would lead to a trade-off between the plasticity and stability [5], and it would be hard to perform long-step incremental learning. Our high-level idea is to learn transferable and diverse representations to bridge the old and new classes in a better feature space. To delve into this problem, we want to answer two questions: (1) Which part of feature representations tends to be forgotten in incremental learning? (2) How to facilitate the representation learning for incremental learning? ",
+        "bbox": [
+            173,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            175
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 Analyzing Forgetting via Spectral Decomposition ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            188,
+            566,
+            204
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In what follows, we explore which part of feature representations tends to be forgotten and may not be transferable across different tasks in incremental learning. To this end, we propose to quantify the sensitivity of the model to different directions in the deep feature space by measuring the similarity of the space before and after learning new tasks. ",
+        "bbox": [
+            174,
+            212,
+            825,
+            268
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Formally, given a feature extractor $f _ { \\pmb { \\theta } , o l d }$ trained on dataset $\\mathcal { D } _ { o l d } = \\{ ( x _ { i } , y _ { i } ) \\} _ { i = 1 } ^ { n }$ . A new dataset $\\mathcal { D } _ { n e w }$ that contains disjoint classes with $\\mathcal { D } _ { o l d }$ is used to update $f _ { \\pmb { \\theta } , o l d }$ , and the updated feature extractor is denoted as $f _ { \\pmb { \\theta } , n e w }$ . For the samples in $\\mathcal { D } _ { o l d }$ , we can get two groups of deep features mapped by $f _ { \\pmb { \\theta } , o l d }$ and $f _ { \\pmb { \\theta } , n e w }$ , respectively. Using eigenvalue decomposition, we could respectively decompose the features mapped by original feature extractor (i.e., $f _ { \\pmb \\theta , o l d } ( \\pmb x _ { i } ) )$ as well as the features mapped by updated feature extractor (i.e., $f _ { \\pmb { \\theta } , n e w } ( \\pmb { x } _ { i } ) )$ to different directions as following: ",
+        "bbox": [
+            173,
+            273,
+            825,
+            358
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fdee3cf260d9b9b490273ed60c2c85f0989f2b3a294d8e425cde73824dce904d.jpg",
+        "text": "$$\n\\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } f _ { \\pmb { \\theta } } ( \\pmb { x } _ { i } ) f _ { \\pmb { \\theta } } ( \\pmb { x } _ { i } ) ^ { \\mathrm { T } } = \\sum _ { j = 1 } ^ { d } \\pmb { u } _ { j } \\lambda _ { j } \\pmb { u } _ { j } ^ { \\mathrm { T } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            363,
+            625,
+            409
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda _ { j }$ represents the eigenvalue with index $j$ and $\\mathbf { \\Delta } \\mathbf { \\em u } _ { j }$ is its eigenvector. $d$ is the dimensionality of the feature space. Through spectral factorization in Eq. (2), we can represent the original and new representations with two groups of eigenvectors: $\\{ \\pmb { u } _ { o l d , 1 } , . . . , \\pmb { u } _ { o l d , d } \\}$ and $\\{ { \\pmb u } _ { n e w , 1 } , . . . , { \\pmb u } _ { n e w , d } \\}$ . ",
+        "bbox": [
+            173,
+            411,
+            825,
+            455
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Next, we investigate the forgetting or transferability of each direction. Shonkwiler [46] introduced the principal angles [47] to measure the similarity of two subspaces. However, it is unreasonable to treat all eigenvectors equally to calculate the principal angles, regardless of their relative eigenvalues. Inspired by [48], we use corresponding angles, denoted by $\\psi$ , to explore the distance between two subspaces in incremental learning: ",
+        "bbox": [
+            174,
+            460,
+            825,
+            531
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 1 (Corresponding Angle) Given two groups of eigenvectors: $\\{ \\pmb { u } _ { o l d , 1 } , . . . , \\pmb { u } _ { o l d , d } \\}$ and $\\{ { \\pmb u } _ { n e w , 1 } , . . . , { \\pmb u } _ { n e w , d } \\}$ , corresponding angle represents the angle between two eigenvectors corresponding to the same eigenvalue value index. The cosine value of the corresponding angle is: ",
+        "bbox": [
+            174,
+            536,
+            825,
+            579
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/674365d4f4a9a90d24ee21182cb39589ad639facbdf171651f19de2fdce7d888.jpg",
+        "text": "$$\n\\cos ( \\psi _ { j } ) = \\frac { \\langle { \\pmb u } _ { o l d , j } , { \\pmb u } _ { n e w , j } \\rangle } { \\| { \\pmb u } _ { o l d , j } \\| \\cdot \\| { \\pmb u } _ { n e w , j } \\| } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            583,
+            606,
+            617
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { \\Delta } \\pmb { u } _ { o l d , j }$ is the $j$ -th eigenvectors with the $j$ -th largest eigenvalue in the old feature space, and similarly for $\\mathbf { \\Delta } \\mathbf { u } _ { n e w , j }$ . Note that $\\| \\pmb { u } _ { o l d , j } \\| = 1$ and $\\| \\boldsymbol { u } _ { n e w , j } \\| = 1$ . For $\\mathrm { I L }$ , the meaning of “preserve old knowledge” refers to maintain the previously learned decision boundary among classes. At representation level, for an old class, the shape (i.e., covariance) of the distributions should not be changed too much. If an eigenvector direction only changes slightly after updating the feature extractor, the corresponding angle is small, and vice versa. Intuitively, the corresponding angle could capture the representation shift between the old and updated feature extractor during incremental learning, and reflect the forgetting along certain directions in the deep feature space. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            733
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Based on the metric defined above, we explore the forgetting of different directions in Class-IL. We use LwF-MC [12, 13] as baseline method and train a ResNet-18 [1] on CIFAR-100 [49] using SGD in a 2-step manner. Concretely, the model is first trained on the first 50 classes and then updated on the other 50 classes. Figure 2 (a) shows the absolute cosine values of corresponding angles between the old and new eigenvectors. We can observe that eigenvectors with larger eigenvalues produce larger similarity (small corresponding angles), which indicates those directions are more transferable and less forgettable across different tasks. On the contrary, the eigenvectors with small eigenvalues prefer to move after updating the model on new tasks, and could be regarded as forgettable directions. ",
+        "bbox": [
+            173,
+            737,
+            825,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Transferable and Diverse Representations. As demonstrated above, the directions with larger eigenvalues transfer better and suffer less forgetting. This thought-provoking observation indicates that our learned representations should have the following properties: (1) Transferability: the eigenvalues of those several significant directions should be enlarged to transfer across tasks (or classes). (2) Diversity: the number of the directions with significant eigenvalues should be increased. Note that those properties are different from that in the common single-task learning scenario. Actually, reducing the number of directions with significant variance has been seen as a form of feature compression [51], which is linked to generalization by information theory [52, 53]. However, the usual concepts of generalization may not entirely be appropriate for IL, since standard learning only aims to learn compact representations within training classes without considering new class generalizability. In IL, those less discriminative directions for the current task could capture useful representations for future tasks. A recent paper [54] has shown that strong compressed representations can actually hurt the generalization ability in the deep metric learning setting. Therefore, to reduce forgetting and enhance the transferability of the representations, it is important to enlarge the eigenvalues and increase the number of eigenvectors with significant variance. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/a847d226ee3580ebc04448949af3e1e4cf495144dc2eb03ca315145529a0457e.jpg",
+        "image_caption": [
+            "Figure 2: (a) Absolute cosine values of corresponding angles. (b) Distribution of eigenvalues for baseline, Mixup [37], LS [50], and our classAug training based models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            169,
+            82,
+            820,
+            190
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            241,
+            825,
+            393
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 Learning Representations via Class Augmentation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            409,
+            575,
+            424
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now exploit our above analysis to propose a simple method for representation learning in ClassIL. Our key idea is to learn transferable and diverse representations by learning more classes at each incremental stage $t$ . To do so, a direct way is to introduce real classes from other datasets as auxiliary. However, it is unrealistic to always have access to other real classes, and which datasets should be used remains unknown. Therefore, we propose class augmentation (classAug) to augment the original classes by synthesizing auxiliary classes based on $\\mathcal { D } _ { t }$ . Concretely, inspired ",
+        "bbox": [
+            173,
+            433,
+            826,
+            516
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "by Mixup [37], classAug randomly interpolates two samples $\\scriptstyle { \\mathbf { { \\mathit { x } } } } _ { a }$ and $\\mathbf { \\delta } _ { \\mathbf { \\mathcal { X } } _ { b } }$ from two different classes $a$ and $b$ to generate a new sample $\\pmb { x } _ { a b } ^ { \\mathrm { n e w } }$ representing a new class: ",
+        "bbox": [
+            174,
+            516,
+            483,
+            571
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2c62d580d54164e680a46a5a9eec602f46e6adcfe628741ea40a58825f6ba714.jpg",
+        "text": "$$\n\\begin{array} { r } { \\pmb { x } _ { a b } ^ { \\mathrm { n e w } } = \\lambda \\pmb { x } _ { a } + ( 1 - \\lambda ) \\pmb { x } _ { b } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            578,
+            413,
+            597
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda$ is a random number of interpolation coefficient. For a $k$ -class problem, we can generate $k ( k - 1 ) / 2$ new classes using the above method, which can be further merged to $m$ auxiliary classes. As a result, the original $k$ -class ",
+        "bbox": [
+            173,
+            603,
+            485,
+            672
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/181a0feee2667ad82c937d1822282b688f49bffd084261e8171eb8fe738b4674.jpg",
+        "image_caption": [
+            "Figure 3: Illustration of classAug. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            522,
+            815,
+            646
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "problem in the current task is extended to a $( k + m )$ -class problem. Moreover, we restrict the $\\lambda$ to be sampled from the interval of [0.4, 0.6], to reduce the overlap between the augmented and original classes. At the end of each $\\mathrm { I L }$ stage, the augmented class nodes in the classifier would be removed. ",
+        "bbox": [
+            174,
+            672,
+            826,
+            714
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Discussion. The proposed classAug is related to Mixup [37] which applies random interpolation on a pair of training samples and the respective one-hot labels. However, the interpolated samples in Mixup are near original data, and the number of classes is not changed, but in our method, it is increased. By learning to classify more classes in each stage $t$ , the model could learn more transferable and diverse representations. Figure 2 (b) displays and compares the eigenvalues 2 of representations learned with different methods on the first 50 classes of CIFAR-100. It is obvious that the proposed classAug can enhance the value of eigenvalues significantly, and produce more directions with significant variance compared with other methods. On the contrary, Mixup and Label-Smoothing (LS) [50] lead to significantly smaller eigenvalues for the several top eigenvectors, which represent more compact representations. Indeed, the compression effect of soft-label based methods has also been demonstrated in [51, 50]. As shown in Section 4.3, classAug can improve the performance of Class-IL significantly, while Mixup and LS have negative effect in our experiments. ",
+        "bbox": [
+            173,
+            719,
+            825,
+            886
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Learning Classifier with Semantic Augmentation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            90,
+            552,
+            107
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As demonstrated in Section 1, classifier bias is another problem in Class-IL. When learning new classes, the previously learned decision boundary would suffer from catastrophic distortion and thus the test samples from old classes could be easily mapped to wrong classes. To overcome this issue, we propose semantic augmentation (semanAug), which leverages the distribution information (i.e., class mean and covariance) of old classes to regularize the learning of the classifier. Formally, for each old class $k \\in \\{ 1 , . . . , \\mathcal { C } _ { o l d } \\}$ , we can generate $M$ instances in the deep feature space from its distribution, i.e., $\\widetilde { z } _ { k } \\backsim \\mathcal { N } ( \\mu _ { k } , \\gamma \\Sigma _ { k } )$ , in which $\\gamma$ is a non-negative coefficient. Then the generated einstances of old classes and real instances of new classes in the deep feature space can be jointly fed to the classifier for minimizing cross-entropy loss: ",
+        "bbox": [
+            173,
+            116,
+            826,
+            242
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bdce3d92d4e559ac126a79ce9857ed09f3abcccc96e0201907bb63030375f671.jpg",
+        "text": "$$\n\\mathcal { L } _ { t } = \\frac { 1 } { n _ { t } } \\sum _ { i = 1 } ^ { n _ { t } } - \\log \\left( \\frac { e ^ { \\varphi _ { y _ { i } } ^ { \\mathrm { T } } z _ { i } + b _ { y _ { i } } } } { \\sum _ { c = 1 } ^ { \\mathcal { C } _ { a l l } } e ^ { \\varphi _ { c } ^ { \\mathrm { T } } z _ { i } + b _ { c } } } \\right) + \\frac { 1 } { \\mathcal { C } _ { o l l } } \\sum _ { k = 1 } ^ { \\mathcal { C } _ { o l l } } \\frac { 1 } { M } \\sum _ { m = 1 } ^ { M } - \\log \\left( \\frac { e ^ { \\varphi _ { k } ^ { \\mathrm { T } } \\widetilde z _ { k , m } + b _ { k } } } { \\sum _ { c = 1 } ^ { \\mathcal { C } _ { a l l } } e ^ { \\varphi _ { c } ^ { \\mathrm { T } } \\widetilde z _ { k , m } + b _ { c } } } \\right) _ { \\textstyle ; }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            196,
+            247,
+            781,
+            291
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$\\mathcal { L } _ { t , o l d }$ {z: loss on generated features of old classes ",
+        "bbox": [
+            511,
+            299,
+            738,
+            310
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $n _ { t }$ is the number of training samples in current task dataset $\\mathcal { D } _ { t }$ , $\\mathcal { C } _ { o l d }$ is the number of total old classes upon stage $t$ , and $\\mathcal { C } _ { a l l } = \\mathcal { C } _ { o l d } + \\mathcal { C } _ { t }$ is the number of all seen classes at stage $t$ . $\\varphi =$ $\\left[ \\varphi _ { 1 } , . . . , \\varphi _ { \\mathcal { C } _ { a l l } } \\right] ^ { \\mathrm { T } } \\in \\mathcal { R } ^ { \\check { C } _ { a l l } \\times d }$ and $b = [ b _ { 1 } , . . . , b _ { { \\mathcal { C } } _ { a l l } } ] ^ { \\mathrm { T } } \\in { \\mathcal { R } } ^ { { \\mathcal { C } } _ { a l l } }$ are the weight matrix and bias vector of the last fully connected layer, respectively. ",
+        "bbox": [
+            173,
+            316,
+            826,
+            375
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Class-IL, the second term in Eq. (5), $\\mathcal { L } _ { t , o l d }$ , is computationally inefficient when $M$ and $\\mathcal { C } _ { o l d }$ are large. In the following, we present an easy-to-compute way to implicitly generate infinite instances in the deep feature space for old classes. ",
+        "bbox": [
+            174,
+            378,
+            823,
+            421
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Upper bound of $\\mathcal { L } _ { t , o l d }$ . Concretely, in the case of $M \\to \\infty$ , the second term in Eq. (5): ",
+        "bbox": [
+            173,
+            426,
+            750,
+            443
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7552e473158fd4bb866ffc27efa5949f3e4828470358fa3d38249529b552a6a3.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\mathcal { L } _ { t , o l d } = \\frac { 1 } { \\tilde { C } _ { o l d } } \\sum _ { k = 1 } ^ { \\tilde { C } _ { o l d } } \\mathbb { E } _ { \\Xi _ { k } } \\left[ - \\log \\left( \\frac { e ^ { \\varphi _ { k } ^ { \\mathsf { T } } \\bar { \\varepsilon } _ { k } + b _ { k } } } { \\sum _ { c = 1 } ^ { \\tilde { C } _ { o l d } } e ^ { \\varphi _ { c } ^ { \\Gamma } \\bar { \\varepsilon } _ { k } + b _ { c } } } \\right) \\right] = \\frac { 1 } { \\tilde { C } _ { o l d } } \\sum _ { k = 1 } ^ { \\tilde { C } _ { o l d } } \\mathbb { E } _ { \\Xi _ { k } } \\left[ \\log \\left( \\displaystyle \\sum _ { c = 1 } ^ { \\tilde { C } _ { o l l } } e ^ { ( \\varphi _ { c } ^ { \\mathsf { T } } - \\varphi _ { k } ^ { \\mathsf { T } } ) \\bar { \\varepsilon } _ { k } + ( b _ { c } - b _ { k } ) } \\right) \\right] } \\\\ { \\displaystyle \\leqslant \\frac { 1 } { \\tilde { C } _ { o l d } } \\sum _ { k = 1 } ^ { \\infty } \\log \\left( \\mathbb { E } _ { \\Xi _ { k } } \\left[ \\displaystyle \\sum _ { c = 1 } ^ { \\tilde { C } _ { o l l } } e ^ { ( \\varphi _ { c } ^ { \\mathsf { T } } - \\varphi _ { k } ^ { \\mathsf { T } } ) \\bar { \\varepsilon } _ { k } + ( b _ { c } - b _ { k } ) } \\right] \\right) } \\\\ { \\displaystyle = \\frac { 1 } { \\tilde { C } _ { o l d } } \\sum _ { k = 1 } ^ { \\infty } \\log \\left( \\displaystyle \\sum _ { c = 1 } ^ { \\tilde { C } _ { o l l } } e ^ { \\nu _ { c , k } ^ { \\mathsf { T } } \\mu _ { k } + ( b _ { c } - b _ { k } ) + \\frac { \\gamma } { 2 } \\upsilon _ { c , k } ^ { \\mathsf { T } } \\Sigma _ { k } \\nu _ { c , k } } \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            448,
+            820,
+            571
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In above equation, ${ \\pmb v } _ { c , k } = { \\pmb \\varphi } _ { c } - { \\pmb \\varphi } _ { k }$ . The inequality is based on Jensen’s inequality $\\mathbb { E } [ \\log ( X ) ] \\leqslant$ $\\log \\mathbb { E } [ X ]$ , and the last equality is obtained by using the moment-generating function $\\mathbb { E } [ e ^ { t X } ] =$ $e ^ { t \\mu + { \\frac { 1 } { 2 } } \\sigma ^ { 2 } t ^ { 2 } }$ , $X \\backsim \\mathcal N ( \\mu , \\sigma ^ { 2 } )$ , due to the fact that $( \\varphi _ { c } - \\varphi _ { k } ) \\widetilde { z } _ { k } + ( b _ { c } - b _ { k } )$ is a Gaussian random evariable. As can be seen, Eq. (6) is an upper bound of original $\\mathcal { L } _ { t , o l d }$ , which provides an elegant and much efficient way to implicitly generate infinite instances in the deep feature space for old classes. The $\\mathcal { L } _ { t , o l d }$ in Eq. (6) can be write in the common cross-entropy loss form: ",
+        "bbox": [
+            173,
+            579,
+            826,
+            669
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8435c172106fae4978404824b5fd946f94c74cc124abc8c2fe6fc99da0439dd3.jpg",
+        "text": "$$\n\\mathcal { L } _ { t , s e m a n A u g } \\triangleq \\mathcal { L } _ { t , o l d } = \\frac { 1 } { \\mathcal { C } _ { o l d } } \\sum _ { k = 1 } ^ { \\mathcal { C } _ { o l d } } - \\log \\left( \\frac { e ^ { \\varphi _ { k } ^ { \\mathrm { T } } \\mu _ { k } + b _ { k } } } { \\sum _ { c = 1 } ^ { \\mathcal { C } _ { a l l } } e ^ { \\varphi _ { c } ^ { \\mathrm { T } } \\mu _ { k } + b _ { c } + \\frac { \\gamma } { 2 } \\upsilon _ { c , k } ^ { \\mathrm { T } } \\Sigma _ { k } v _ { c , k } } } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            675,
+            745,
+            719
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, $\\mathcal { L } _ { t , o l d }$ implicitly performs semantic transformations for $\\mu _ { k }$ based on $\\Sigma _ { k }$ . To maintain the decision boundary, $\\gamma$ should be smaller if the distribution of a class is near the decision boundary; instead, $\\gamma$ should be bigger if the distance is relatively far. We set $\\gamma = 2$ in our experiments. In addition, we can observe that when $\\gamma = 0$ , only the class means are used for knowledge retention. ",
+        "bbox": [
+            173,
+            724,
+            825,
+            781
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Discussion. (1) Although the derivation of the upper bound in Eq. (6) is similar with ISDA [22], both our motivation and the way to leverage semanAug are different from ISDA. When learning new classes, we only apply semanAug for the class mean of each old class based on the memorized distribution information. While ISDA applies semanAug on all the training samples to improve generalization in standard supervised learning. In addition, a crucial step in ISDA is to estimate the mean and covariance matrix of each class in an online manner. Differently, semanAug is naturally suitable for Class-IL, since the distribution of old classes can be estimated with all training samples at the end of each learning stage. (2) Using previous class statistics for $\\mathrm { I L }$ has also been explored in IL2M [55]. However, our method differs from IL2M in both the statistics information and the way to leverage them. First, The class statistics in IL2M is the prediction score of the classifier, while ours is the class distribution statistics in the deep feature space. Second, IL2M uses the class statistics to calibrate the prediction of a continual learner in a post-processing manner, while our method leverage the statistics to automatically learn a balanced classifier. ",
+        "bbox": [
+            173,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/922d60182efbe7fdd1ddad11c8566318e3d0dd841048f2bc6908945a1fbce749.jpg",
+        "image_caption": [
+            "Figure 4: Illustration of our dual augmentation framework (IL2A) for Class-IL. On the one hand, the training samples of new classes at current task are augmented via the proposed classAug. On the other hand, the distributions of old classes are retained by semanAug in the deep feature space. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            93,
+            815,
+            239
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            309,
+            825,
+            366
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 The Dual Augmentation Learning Framework ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            381,
+            534,
+            397
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "With classAug for representation bias and semanAug for classifier bias, Figure 4 describes the learning process of the dual augmentation framework (IL2A). We also use the well-known knowledge distillation (KD) [19] for two reasons. Firstly, classAug and KD are complementary and focus on different aspect of learning representation. Secondly, KD can reduce the change of feature extractor, which is crucial for semanAug because it implicitly generate instances in the deep feature space from old distribution. The total learning objective at each stage $t$ is as following: ",
+        "bbox": [
+            173,
+            406,
+            825,
+            491
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/597d07fee78ab248bc3d9559e70a28eadafeda15ec7ddb6134a7c053f30f8b3e.jpg",
+        "text": "$$\n\\mathcal { L } _ { t } = \\mathcal { L } _ { t , n e w } + \\alpha \\mathcal { L } _ { t , s e m a n A u g } + \\beta \\mathcal { L } _ { t , k d } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            497,
+            633,
+            515
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha$ and $\\beta$ are two hyper-parameters. $\\mathcal { L } _ { t , n e w }$ and $\\mathcal { L } _ { t , s e m a n A u g }$ are shown in Eq. (5) and Eq. (7), respectively. $\\begin{array} { r } { \\mathcal { L } _ { t , k d } = \\frac { 1 } { n _ { t } } \\sum _ { i = 1 } ^ { n _ { t } } \\| f _ { \\pmb { \\theta } _ { t - 1 } } ( \\pmb { x } _ { i } ) - f _ { \\pmb { \\theta } _ { t } } ( \\pmb { x } _ { i } ) \\| } \\end{array}$ . Note that $\\mathcal { L } _ { t , n e w }$ and $\\mathcal { L } _ { t , s e m a n A u g }$ are applied to both the original and synthesized samples. Algorithm 1 presents the pseudo code of IL2A. ",
+        "bbox": [
+            174,
+            521,
+            826,
+            566
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            585,
+            312,
+            603
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 Evaluation Protocol ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            616,
+            351,
+            631
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We perform our experiments on CIFAR-100 [49] and Tiny-ImageNet [56]. A common setting is to train the model on half of classes for first task, and equal classes in the remaining incremental steps. Based on this, we split the CIFAR-100 dataset in different settings: $5 0 + 5 \\times 1 0$ , $5 0 + \\pm 0 \\times 5$ , $4 0 + 2 { \\pmb \\theta } \\times 3$ . For instance, $5 0 +$ $I { \\pmb \\theta } \\times 5$ represents that the first task contains 50 classes and there are 5 classes for the following 10 tasks. Similarly, the settings for Tiny-ImageNet are $1 0 0 + { \\pmb { 5 } } \\times 2 0 $ , $1 0 0 +$ $1 0 \\times 1 0$ and $1 0 0 { + } 2 { \\pm } 5$ . Intuitively, more classes in each tasks requires the model to learn a harder problem for each task, while increasing the length of the task sequence challenges the model’s retention. ",
+        "bbox": [
+            173,
+            641,
+            446,
+            877
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: IL2A: Dual augmentation algorithm ",
+        "text_level": 1,
+        "bbox": [
+            459,
+            647,
+            792,
+            661
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Randomly initialize $\\Theta ^ { 0 } = \\{ \\theta ^ { 0 } , \\varphi ^ { 0 } \\}$ ; ${ \\mathcal { S } } ^ { 0 } = \\emptyset$ ;   \nforeach incremental stage $t \\in \\{ 1 , . . . , T \\}$ do Input: model $\\Theta ^ { t - 1 }$ , data $\\mathcal { D } _ { t } = \\{ ( x _ { i } , y _ { i } ) \\} _ { i = 1 } ^ { n _ { t } }$ ; Output: model $\\Theta ^ { t }$ ; $\\Theta ^ { t } \\bar {  } \\Theta ^ { t - 1 }$ ; $\\mathcal { D } _ { t , a u g } = \\{ ( \\boldsymbol { x } _ { i } ^ { \\prime } , \\boldsymbol { y } _ { i } ^ { \\prime } ) \\} _ { i = 1 } ^ { n _ { t } ^ { \\prime } }$ via classAug; add class nodes for augmented classes; if $t = 1$ then train $\\Theta ^ { t }$ by minimizing $\\mathcal { L } ( g _ { \\varphi } ( f _ { \\theta } ( \\pmb { x } ^ { \\prime } ) ) , y ^ { \\prime } )$ ; else train $\\Theta ^ { t }$ by minimizing Eq. (8); $s \\gets$ compute $\\{ \\mu , \\Sigma \\}$ for each class in $\\mathcal { D } _ { t }$ ; $S ^ { t } \\gets S ^ { t - 1 } \\cup s ;$ remove augmented class nodes in classifier; ",
+        "bbox": [
+            459,
+            665,
+            794,
+            876
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/fcb711f00b1081d5d60c7b70d9e62c8c544bcc4686b010481488154f5665887a.jpg",
+        "image_caption": [
+            "Figure 5: Results of top-1 accuracy on CIFAR-100 and Tiny-ImageNet under different settings. Solid lines present methods that do not store old exemplars, dashed lines present data replay based methods. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            85,
+            826,
+            319
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "in each experiment. All models are trained using Adam [57] optimizer with an initial learning rate of 0.001 for 100 epochs with the mini-batch size of 64. The learning rate is reduced by a factor of 10 at 45 and 90 epochs. We use the same hyper-parameter value for all experiments. Specifically, we set $\\alpha = 1 0$ and $\\beta = 1 0$ in Eq. (8). The number of augmented classes (i.e. The number of augmented classes (i.e., $m$ ) depends on the number of (original) classes at current incremental step. Taking CIFAR-100 as an example, the $m$ is 45 for 5 phases setting where each incremental step has 10 classes; and $m$ is 10 for 10 phases setting where each incremental step has 5 classes. At the end of each incremental stage, we evaluate the model on all seen classes after removing the class nodes of the $m$ augmented classes in the classifier. Our code is available at https://github.com/Impression2805/IL2A. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            512
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparison Methods. Our method (IL2A) does not store any old samples for replay when learning new classes. Therefore, we first compare IL2A with several non-exemplar based approaches: MAS [16], LwF-MC [13], MUC [58], LwM [59]. In addition, we also compare with several exemplar based methods such as iCaRL [13], EEIL [18] and LUCIR [19]. Specifically, for the data replay based methods, we follow [13, 19] to store 20 samples for each class using ‘herd’ selection technique [13]. We report the average top-1 accuracy of all previously seen classes up to each incremental step t. For iCaRL, we respectively report its results of CNN predictions and nearest-mean-of-exemplars classification, denoted as iCaRL-CNN and iCaRL-NME. ",
+        "bbox": [
+            173,
+            520,
+            825,
+            630
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Experimental Results ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            650,
+            362,
+            665
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Main Results. Comparative results are shown in Figure 5. Firstly, we observe that our method performs much better than non-exemplar based methods such as LwF-MC and MUC in the trend of accuracy curve under different settings. Particularly, the gap appears unbridgeable in the long-step Class-IL setting, e.g., 10 phases and 20 phases. This suggests that only constraining old parameters does not suffice to prevent forgetting. We argue that this is partly due to the unaddressed classifier bias. When compared to representative data replay based methods such as iCaRL, EEIL and LUCIR, our method remarkably shows strong performance without storing old samples. ",
+        "bbox": [
+            173,
+            676,
+            825,
+            773
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The success of our method can contribute to the proposed classAug and semanAug. Specifically, classAug is applied to new classes of current task, which enables the model to learn more transferable and diverse representations for future classes and in turn, reduces the forgetting of old parameters when learning new classes. While semanAug is applied to old classes of previous tasks, which leverage the valuable distribution information of old classes to learn a unified classifier to connect the classes from different tasks to each other. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            863
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ablation Study. To evaluate the effect of each component in IL2A, we perform the ablation study and show the results of 10 phases setting (CIFAR-100) in Table 1. Specifically, the baseline denotes the method that does not generate pseudo-instance using semanAug, but only replays the class-mean of each old class when training new classes. By doing so, we aim to validate the effectiveness of semanAug compared with only replaying class-mean. In summary, we can observe that: (1) Baseline improves the performance of KD significantly. (2) SemanAug improves the performance of baseline from $3 4 . 7 1 \\%$ to $4 2 . 0 9 \\%$ . Those results indicate the effect of the distribution information for maintaining old knowledge in Class-IL. (3) ClassAug also has remarkably effect on baseline, and (4) the performance can be further improved by combing with semanAug, which indicates that those two modules are complementary. Similar results are observed in other settings of CIFAR-100 and Tiny-ImageNet datasets. (5) As for the computational complexity, classAug involves input level sample mixing and the augmented samples are fed to feature extractor. Differently, semanAug performs implicit old instance generation in the deep feature space. Therefore, semanAug is cheaper compared with classAug from the computation perspective. ",
+        "bbox": [
+            176,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/05cca1f8f6db26a183def87fe02b1c2a8780825a76ebcfab0dcd1e1b41f01d4e.jpg",
+        "table_caption": [
+            "Table 1: The effect of each component in IL2A. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Method\\Incremental stage</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>Final</td></tr><tr><td rowspan=4 colspan=1>Knowledge Distillationbaseline+ semanAug+ classAug</td><td rowspan=1 colspan=1>78.78</td><td rowspan=1 colspan=1>30.18</td><td rowspan=1 colspan=1>20.71</td><td rowspan=1 colspan=1>14.61</td><td rowspan=1 colspan=1>11.87</td><td rowspan=1 colspan=1>8.80</td><td rowspan=1 colspan=1>7.70</td><td rowspan=1 colspan=1>7.23</td><td rowspan=1 colspan=1>7.10</td><td rowspan=1 colspan=1>6.05</td><td rowspan=1 colspan=1>6.04</td></tr><tr><td rowspan=1 colspan=1>78.86</td><td rowspan=1 colspan=1>62.85</td><td rowspan=1 colspan=1>56.96</td><td rowspan=1 colspan=1>54.66</td><td rowspan=1 colspan=1>51.72</td><td rowspan=1 colspan=1>47.33</td><td rowspan=1 colspan=1>43.61</td><td rowspan=1 colspan=1>40.12</td><td rowspan=1 colspan=1>40.76</td><td rowspan=1 colspan=1>36.55</td><td rowspan=1 colspan=1>34.71</td></tr><tr><td rowspan=1 colspan=1>79.16</td><td rowspan=1 colspan=1>69.14</td><td rowspan=1 colspan=1>60.68</td><td rowspan=1 colspan=1>58.18</td><td rowspan=1 colspan=1>54.77</td><td rowspan=1 colspan=1>50.89</td><td rowspan=1 colspan=1>48.45</td><td rowspan=1 colspan=1>46.29</td><td rowspan=1 colspan=1>46.97</td><td rowspan=1 colspan=1>44.38</td><td rowspan=1 colspan=1>42.09</td></tr><tr><td rowspan=1 colspan=1>79.72</td><td rowspan=1 colspan=1>68.30</td><td rowspan=1 colspan=1>64.15</td><td rowspan=1 colspan=1>60.15</td><td rowspan=1 colspan=1>56.21</td><td rowspan=1 colspan=1>52.61</td><td rowspan=1 colspan=1>51.48</td><td rowspan=1 colspan=1>46.48</td><td rowspan=1 colspan=1>46.36</td><td rowspan=1 colspan=1>43.63</td><td rowspan=1 colspan=1>41.56</td></tr><tr><td rowspan=1 colspan=1> + classAug + semanAug</td><td rowspan=1 colspan=1>81.08</td><td rowspan=1 colspan=1>74.54</td><td rowspan=1 colspan=1>66.28</td><td rowspan=1 colspan=1>63.89</td><td rowspan=1 colspan=1>58.80</td><td rowspan=1 colspan=1>54.97</td><td rowspan=1 colspan=1>51.32</td><td rowspan=1 colspan=1>48.64</td><td rowspan=1 colspan=1>49.74</td><td rowspan=1 colspan=1>47.05</td><td rowspan=1 colspan=1>45.07</td></tr></table>",
+        "bbox": [
+            181,
+            103,
+            823,
+            202
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            220,
+            826,
+            375
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 Further Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            391,
+            331,
+            406
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ClassAug Improves both Plasticity and Stability in Class-IL. To analyze the effectiveness of classAug more concretely, we explore how it affects the new tasks accuracy (↑) and average forgetting (↓) (CIFAR-100, 10 phases setting). Average forgetting [60] is defined to estimate the forgetting of previous tasks. The forgetting measure $\\bar { f } _ { k } ^ { i }$ of the $i$ -th task after training $k$ -th task is defined as $f _ { k } ^ { i } = \\operatorname* { m a x } _ { t \\in 1 , \\ldots , k - 1 } ( a _ { t , i } - a _ { k , i } ) , \\forall i < k$ , in which $a _ { m , n }$ is the accuracy of task $n$ after training task $m$ . ",
+        "bbox": [
+            173,
+            417,
+            826,
+            494
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The average forgetting measure $F _ { k }$ is then defined as 1k−1 Pk−1i=1 f ik. Intuitively, new task accuracy can be viewed as the plasticity of the incremental learner and the average forgetting can be viewed as the stability of the incremental learner. Figure 6 (a) and (b) report the results, from which we see that classAug simultaneously improves the new task accuracy and reduces the average forgetting. Specifically, the significant improvement on new task accuracy implies that the model training with classAug is a good initialization for the following tasks. Consequently, classAug is effective to improve the trade-off between plasticity and stability of a continual learner. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            598
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/74b1ad39f42f5a89b574e88fa477fed16c9e657e8a74d5d3be13dc2d0e41c807.jpg",
+        "image_caption": [
+            "Figure 6: (a, b) ClassAug can simultaneously improve the new task accuracy and reduce the average forgetting. (c) Compared with classAug, Mixup and LS have negative effect for Class-IL. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            611,
+            820,
+            729
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Compare ClassAug with Other Regularizers. We compare the proposed classAug with Mixup and LS in Figure 6 (c), where the baseline (with semanAug) represents our IL2A without using classAug. As can be seen, Mixup and LS have negative effect on the final accuracy. This phenomenon could be interpreted based on the analysis in Section 3.1.1 and Figure 2 (b). Specifically, those regularizers result in more compressed representations, damaging the transferability of the representations. Besides, the label smoothing strategy also affects the weights of old classes in the classifier, thus increasing the classifier bias. Similar results have also been reported in [61]. ",
+        "bbox": [
+            173,
+            779,
+            825,
+            877
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Discussion of Covariance Matrix. In our main experiments, we use the original covariance matrix for semanAug. However, storing the original covariance matrix might be inefficient when the matrix dimension is large. An alternative way is to only store the elements on the diagonal, which could greatly reduce the cost of memory. Figure 7 also reports the results of using the diagonal covariance matrix. Under different settings, using the original covariance matrix is slightly better than the diagonal form. This is reasonable because the original covariance matrix stores more distribution information of old classes. However, using the diagonal covariance matrix would be more memory-efficient in practice. ",
+        "bbox": [
+            173,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/16676de3fa28355396593ce2fac1d385d8b52e0ede9eb599fca010e11dc5394e.jpg",
+        "table_caption": [
+            "Table 2: OOD detection results. $\\uparrow$ indicates higher is better. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">0OD</td><td colspan=\"3\">AUROC↑</td><td colspan=\"3\">AUPR-In↑</td><td colspan=\"3\">AUPR-Out个</td></tr><tr><td>baseline</td><td>Mixup</td><td>classAug</td><td>baseline</td><td>Mixup</td><td>classAug</td><td>baseline</td><td>Mixup</td><td>classAug</td></tr><tr><td>MNIST</td><td>87.02</td><td>92.46</td><td>94.99</td><td>79.89</td><td>89.00</td><td>93.05</td><td>92.26</td><td>95.48</td><td>97.20</td></tr><tr><td>Fashion-MNIST</td><td>90.28</td><td>93.37</td><td>94.40</td><td>86.18</td><td>89.11</td><td>92.43</td><td>94.26</td><td>96.19</td><td>96.78</td></tr><tr><td>LSUN</td><td>88.50</td><td>88.80</td><td>93.90</td><td>83.48</td><td>74.71</td><td>91.08</td><td>92.92</td><td>94.09</td><td>96.73</td></tr><tr><td>Tiny-ImageNet</td><td>88.49</td><td>84.96</td><td>93.92</td><td>83.84</td><td>64.02</td><td>91.77</td><td>92.70</td><td>92.19</td><td>96.55</td></tr><tr><td>Mean</td><td>88.57</td><td>89.90</td><td>94.30</td><td>83.35</td><td>79.21</td><td>92.08</td><td>93.04</td><td>94.49</td><td>96.81</td></tr></table>",
+        "bbox": [
+            181,
+            104,
+            825,
+            210
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            227,
+            823,
+            310
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ClassAug Improves Confidence Reliability. During continuous use of a machine learning system in open-world applications, there are mainly three key steps [62]. The first step is out-of-distribution (OOD) detection [63], which requires the system to detect unknown samples from novel classes. The second step is to label the collected unknown samples by humans or automatic algorithms [64]. Finally, the system must scale and adapt incrementally to learn the novel classes, which is the Class-IL problem studied in this paper. Recently studies found that DNNs are overconfident for their predictions [63, 65], lacking the ability to detect samples from unknown classes. In real-world applications, we expect a continual learner has good OOD detection ability. ",
+        "bbox": [
+            174,
+            315,
+            599,
+            482
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/b0ee6625c379c219150f00397ededed20299312038543491731ac6f129574fbc.jpg",
+        "image_caption": [
+            "Figure 7: Original v.s. diagonal covariance matrix. CIFAR-100. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            614,
+            320,
+            825,
+            444
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We explore the OOD detection ability of the proposed classAug. Concretely, we train a ResNet-18 on CIFAR-10, and the test samples from CIFAR-10 are in-distribution. For OOD examples, we test on MNIST [66], Fashion-MNIST [67], LSUN (resized) [68] and Tiny-ImageNet (resized). As shown in Table 2, classAug noticeably improves the OOD detection performance of baseline [63] on commonly used metrics such as AUROC, AUPR-In and AUPR-Out [63]. By recognizing synthetic samples, DNNs could learn more robust and transferable representations which could be generalized to OOD samples. Moreover, as shown in Table 2, Mixup sometimes damages the performance of OOD detection, which further demonstrates the superiority of classAug. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            599
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            621,
+            299,
+            637
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a simple and effective dual augmentation framework to address the representation bias and classifier bias in Class-IL. We first investigate the transferability (or forgetting) of representations via spectral decomposition, which motivates us to propose classAug that can learn transferable, diverse and less compact representations for IL. Furthermore, we propose to use semanAug to implicitly generate infinite instances of old classes in the deep feature space during jointly learning of the unified classifier. Experiments show that our method could achieve remarkable performance compared with state-of-the-art Class-IL methods. Future works will consider the dual augmentation framework for more challenging scenarios like Class-IL with distribution shift and OOD data, few-shot Class-IL, and federated incremental learning. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            777
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            799,
+            338,
+            816
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work has been supported by the National Key Research and Development Program under Grant No. 2018AAA0100400, the National Natural Science Foundation of China (NSFC) grants U20A20223, 61633021, 62076236, 61721004, the Key Research Program of Frontier Sciences of CAS under Grant ZDBS-LY-7004, and the Youth Innovation Promotion Association of CAS under Grant 2019141. ",
+        "bbox": [
+            176,
+            832,
+            825,
+            901
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pages 770–778, 2016. 1, 4, 7   \n[2] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, pages 248–255, 2009. 1   \n[3] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NeurIPS, pages 1097–1105, 2012. 1, 3   \n[4] Gregory Ditzler, Manuel Roveri, Cesare Alippi, and Robi Polikar. Learning in nonstationary environments: A survey. IEEE Computational Intelligence Magazine, 10(4):12–25, 2015. 1   \n[5] German I Parisi, Ronald Kemker, Jose L Part, Christopher Kanan, and Stefan Wermter. Continual lifelong learning with neural networks: A review. Neural Networks, 113:54–71, 2019. 1, 4   \n[6] Matthias Delange, Rahaf Aljundi, Marc Masana, Sarah Parisot, Xu Jia, Ales Leonardis, Greg Slabaugh, and Tinne Tuytelaars. A continual learning survey: Defying forgetting in classification tasks. IEEE Trans. Pattern Anal. Mach. Intell., 2021. 1   \n[7] Raia Hadsell, Dushyant Rao, Andrei A Rusu, and Razvan Pascanu. Embracing change: Continual learning in deep neural networks. Trends in Cognitive Sciences, 2020. 1   \n[8] Ian J. Goodfellow, M. Mirza, Xia Da, Aaron C. Courville, and Yoshua Bengio. An empirical investigation of catastrophic forgeting in gradient-based neural networks. CoRR, 2014. 1   \n[9] M. McCloskey and N. J. Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. Psychology of Learning and Motivation, pages 109–165, 1989. 1   \n[10] Robert M French. Interactive tandem networks and the sequential learning problem. Citeseer. 1   \n[11] J. Kirkpatrick, Razvan Pascanu, Neil C. Rabinowitz, J. Veness, G. Desjardins, Andrei A. Rusu, K. Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, Demis Hassabis, C. Clopath, D. Kumaran, and Raia Hadsell. Overcoming catastrophic forgetting in neural networks. Proceedings of the National Academy of Sciences, pages 3521 – 3526, 2017. 1, 2, 3, 4   \n[12] Zhizhong Li and Derek Hoiem. Learning without forgetting. IEEE Trans. Pattern Anal. Mach. Intell., pages 2935–2947, 2018. 1, 2, 3, 4   \n[13] Sylvestre-Alvise Rebuffi, A. Kolesnikov, Georg Sperl, and Christoph H. Lampert. icarl: Incremental classifier and representation learning. In CVPR, pages 5533–5542, 2017. 1, 3, 4, 8   \n[14] Ameya Prabhu, Philip HS Torr, and Puneet K Dokania. Gdumb: A simple approach that questions our progress in continual learning. In ECCV, pages 524–540, 2020. 1   \n[15] Friedemann Zenke, Ben Poole, and Surya Ganguli. Continual learning through synaptic intelligence. In ICML, pages 3987–3995, 2017. 1, 2, 3, 4   \n[16] Rahaf Aljundi, Francesca Babiloni, Mohamed Elhoseiny, Marcus Rohrbach, and Tinne Tuytelaars. Memory aware synapses: Learning what (not) to forget. In ECCV, pages 139–154, 2018. 1, 2, 3, 4, 8   \n[17] Y. Wu, Yan-Jia Chen, Lijuan Wang, Yuancheng Ye, Zicheng Liu, Yandong Guo, and Yun Fu. Large scale incremental learning. In CVPR, pages 374–382, 2019. 1, 3   \n[18] Francisco M Castro, Manuel J Marín-Jiménez, Nicolás Guil, Cordelia Schmid, and Karteek Alahari. End-to-end incremental learning. In ECCV, pages 233–248, 2018. 1, 2, 8   \n[19] Saihui Hou, Xinyu Pan, Chen Change Loy, Zilei Wang, and D. Lin. Learning a unified classifier incrementally via rebalancing. In CVPR, pages 831–839, 2019. 2, 3, 7, 8   \n[20] Bowen Zhao, Xi Xiao, Guojun Gan, Bin Zhang, and Shu-Tao Xia. Maintaining discrimination and fairness in class incremental learning. In CVPR, pages 13205–13214, 2020. 2   \n[21] Laurens Maaten, Minmin Chen, Stephen Tyree, and Kilian Weinberger. Learning with marginalized corrupted features. In ICML, pages 410–418, 2013. 2   \n[22] Yulin Wang, Gao Huang, Shiji Song, Xuran Pan, Yitong Xia, and Cheng Wu. Regularizing deep networks with semantic data augmentation. IEEE Trans. Pattern Anal. Mach. Intell., 2021. 2, 3, 6   \n[23] Yen-Chang Hsu, Yen-Cheng Liu, Anita Ramasamy, and Zsolt Kira. Re-evaluating continual learning scenarios: A categorization and case for strong baselines. arXiv preprint arXiv:1810.12488, 2018. 3   \n[24] Gido M Van de Ven and Andreas S Tolias. Three scenarios for continual learning. arXiv preprint arXiv:1904.07734, 2019. 3   \n[25] Arthur Douillard, Matthieu Cord, Charles Ollion, Thomas Robert, and Eduardo Valle. Podnet: Pooled outputs distillation for small-tasks incremental learning. In ECCV, pages 86–102, 2020. 3   \n[26] Matthew Riemer, Ignacio Cases, Robert Ajemian, Miao Liu, Irina Rish, Yuhai Tu, and Gerald Tesauro. Learning to learn without forgetting by maximizing transfer and minimizing interference. In ICLR, 2018. 3   \n[27] David Lopez-Paz and Marc’Aurelio Ranzato. Gradient episodic memory for continual learning. In NeurIPS, 2017. 3   \n[28] Arslan Chaudhry, Marc’Aurelio Ranzato, Marcus Rohrbach, and Mohamed Elhoseiny. Efficient lifelong learning with a-gem. In ICLR, 2019. 3   \n[29] Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. In NeurIPS, pages 2994–3003, 2017. 3   \n[30] Chenshen Wu, L. Herranz, X. Liu, Y. Wang, Joost van de Weijer, and B. Raducanu. Memory replay gans: Learning to generate new categories without forgetting. In NeurIPS, pages 5962–5972, 2018. 3   \n[31] Ye Xiang, Ying Fu, Pan Ji, and Hua Huang. Incremental learning using conditional adversarial networks. In ICCV, pages 6618–6627, 2019. 3   \n[32] Ronald Kemker and Christopher Kanan. Fearnet: Brain-inspired model for incremental learning. In ICLR, 2018. 3   \n[33] Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016. 3   \n[34] Arun Mallya and Svetlana Lazebnik. Packnet: Adding multiple tasks to a single network by iterative pruning. In CVPR, pages 7765–7773, 2018. 3   \n[35] Joan Serra, Didac Suris, Marius Miron, and Alexandros Karatzoglou. Overcoming catastrophic forgetting with hard attention to the task. In ICML, pages 4548–4557, 2018. 3   \n[36] Jaehong Yoon, Eunho Yang, Jeongtae Lee, and Sung Ju Hwang. Lifelong learning with dynamically expandable networks. In ICLR, 2018. 3   \n[37] Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. Mixup: Beyond empirical risk minimization. In ICLR, 2018. 3, 5   \n[38] Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In ICCV, pages 6023–6032, 2019. 3   \n[39] Yoshua Bengio, Grégoire Mesnil, Yann Dauphin, and Salah Rifai. Better mixing via deep representations. In ICML, pages 552–560, 2013. 3   \n[40] Paul Upchurch, Jacob Gardner, Geoff Pleiss, Robert Pless, Noah Snavely, Kavita Bala, and Kilian Weinberger. Deep feature interpolation for image content changes. In CVPR, pages 7064–7073, 2017. 3   \n[41] Qi Cai, Yu Wang, Yingwei Pan, Ting Yao, and Tao Mei. Joint contrastive learning with infinite possibilities. In NeurIPS, 2020. 3   \n[42] Shuang Li, Mixue Xie, Kaixiong Gong, Chi Harold Liu, Yulin Wang, and Wei Li. Transferable semantic augmentation for domain adaptation. arXiv preprint arXiv:2103.12562, 2021. 3   \n[43] Shuang Li, Kaixiong Gong, Chi Harold Liu, Yulin Wang, Feng Qiao, and Xinjing Cheng. Metasaug: Meta semantic augmentation for long-tailed visual recognition. arXiv preprint arXiv:2103.12579, 2021. 3   \n[44] Pietro Buzzega, Matteo Boschini, Angelo Porrello, Davide Abati, and Simone Calderara. Dark experience for general continual learning: a strong, simple baseline. In NeurIPS, 2020. 3, 7   \n[45] Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015. 3   \n[46] Clayton Shonkwiler. Poincaré duality angles for riemannian manifolds with boundary. arXiv preprint arXiv:0909.1967, 2009. 4   \n[47] Jianming Miao and Adi Ben-Israel. On principal angles between subspaces in rn. Linear algebra and its applications, 171:81–98, 1992. 4   \n[48] Xinyang Chen, Sinan Wang, Mingsheng Long, and Jianmin Wang. Transferability vs. discriminability: Batch spectral penalization for adversarial domain adaptation. In ICML, pages 1081–1090, 2019. 4   \n[49] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. Technical report, 2009. 4, 7   \n[50] Rafael Müller, Simon Kornblith, and Geoffrey E. Hinton. When does label smoothing help? In NeurIPS, pages 4696–4705, 2019. 5   \n[51] Vikas Verma, Alex Lamb, Christopher Beckham, Amir Najafi, Ioannis Mitliagkas, David Lopez-Paz, and Yoshua Bengio. Manifold mixup: Better representations by interpolating hidden states. In ICML, pages 6438–6447, 2019. 5   \n[52] Naftali Tishby and Noga Zaslavsky. Deep learning and the information bottleneck principle. In 2015 IEEE Information Theory Workshop (ITW), pages 1–5, 2015. 5   \n[53] Ravid Shwartz-Ziv and Naftali Tishby. Opening the black box of deep neural networks via information. arXiv preprint arXiv:1703.00810, 2017. 5   \n[54] Karsten Roth, Timo Milbich, Samarth Sinha, Prateek Gupta, Björn Ommer, and Joseph Paul Cohen. Revisiting training strategies and generalization performance in deep metric learning. In ICML, 2020. 5   \n[55] Eden Belouadah and Adrian Popescu. Il2m: Class incremental learning with dual memory. In ICCV, pages 583–592, 2019. 6   \n[56] Leon Yao and John Miller. Tiny imagenet classification with convolutional neural networks. CS 231N. 7   \n[57] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015. 8   \n[58] Yu Liu, Sarah Parisot, Gregory G. Slabaugh, Xu Jia, Ales Leonardis, and Tinne Tuytelaars. More classifiers, less forgetting: A generic multi-classifier paradigm for incremental learning. In ECCV, pages 699–716, 2020. 8   \n[59] Prithviraj Dhar, Rajat Vikram Singh, Kuan-Chuan Peng, Ziyan Wu, and Rama Chellappa. Learning without memorizing. In CVPR, pages 5138–5146, 2019. 8   \n[60] Arslan Chaudhry, P. Dokania, Thalaiyasingam Ajanthan, and P. Torr. Riemannian walk for incremental learning: Understanding forgetting and intransigence. In ECCV, pages 532–547, 2018. 9   \n[61] Sudhanshu Mittal, Silvio Galesso, and Thomas Brox. Essentials for class incremental learning. arXiv preprint arXiv:2102.09517, 2021. 9   \n[62] Xu-Yao Zhang, Cheng-Lin Liu, and Ching Y Suen. Towards robust pattern recognition: A review. Proceedings of the IEEE, 108(6):894–922, 2020. 10   \n[63] Dan Hendrycks and Kevin Gimpel. A baseline for detecting misclassified and out-of-distribution examples in neural networks. In ICLR, 2017. 10   \n[64] Kai Han, Sylvestre-Alvise Rebuffi, Sébastien Ehrhardt, Andrea Vedaldi, and Andrew Zisserman. Autonovel: Automatically discovering and learning novel visual categories. IEEE Trans. Pattern Anal. Mach. Intell., 2021. 10   \n[65] Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q Weinberger. On calibration of modern neural networks. In ICML, pages 1321–1330, 2017. 10   \n[66] Yann LeCun and Corinna Cortes. The mnist database of handwritten digits. 2005. 10   \n[67] Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017. 10   \n[68] Fisher Yu, Yinda Zhang, Shuran Song, Ari Seff, and Jianxiong Xiao. Lsun: Construction of a large-scale image dataset using deep learning with humans in the loop. ArXiv, abs/1506.03365, 2015. 10 ",
+        "bbox": [
+            169,
+            73,
+            826,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            50,
+            828,
+            919
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            50,
+            830,
+            900
+        ],
+        "page_idx": 12
+    }
+]

parse/train/Bkg6RiCqY7/Bkg6RiCqY7.md

@@ -0,0 +1,342 @@
+# DECOUPLED WEIGHT DECAY REGULARIZATION
+
+Ilya Loshchilov & Frank Hutter
+
+University of Freiburg   
+Freiburg, Germany,   
+ilya.loshchilov@gmail.com, fh@cs.uni-freiburg.de
+
+# ABSTRACT
+
+$\mathrm { L _ { 2 } }$ regularization and weight decay regularization are equivalent for standard stochastic gradient descent (when rescaled by the learning rate), but as we demonstrate this is not the case for adaptive gradient algorithms, such as Adam. While common implementations of these algorithms employ $\mathrm { L _ { 2 } }$ regularization (often calling it “weight decay” in what may be misleading due to the inequivalence we expose), we propose a simple modification to recover the original formulation of weight decay regularization by decoupling the weight decay from the optimization steps taken w.r.t. the loss function. We provide empirical evidence that our proposed modification (i) decouples the optimal choice of weight decay factor from the setting of the learning rate for both standard SGD and Adam and (ii) substantially improves Adam’s generalization performance, allowing it to compete with SGD with momentum on image classification datasets (on which it was previously typically outperformed by the latter). Our proposed decoupled weight decay has already been adopted by many researchers, and the community has implemented it in TensorFlow and PyTorch; the complete source code for our experiments is available at https://github.com/loshchil/AdamW-and-SGDW
+
+# 1 INTRODUCTION
+
+Adaptive gradient methods, such as AdaGrad (Duchi et al., 2011), RMSProp (Tieleman & Hinton, 2012), Adam (Kingma & Ba, 2014) and most recently AMSGrad (Reddi et al., 2018) have become a default method of choice for training feed-forward and recurrent neural networks (Xu et al., 2015; Radford et al., 2015). Nevertheless, state-of-the-art results for popular image classification datasets, such as CIFAR-10 and CIFAR-100 Krizhevsky (2009), are still obtained by applying SGD with momentum (Gastaldi, 2017; Cubuk et al., 2018). Furthermore, Wilson et al. (2017) suggested that adaptive gradient methods do not generalize as well as SGD with momentum when tested on a diverse set of deep learning tasks, such as image classification, character-level language modeling and constituency parsing. Different hypotheses about the origins of this worse generalization have been investigated, such as the presence of sharp local minima (Keskar et al., 2016; Dinh et al., 2017) and inherent problems of adaptive gradient methods (Wilson et al., 2017). In this paper, we investigate whether it is better to use $\mathrm { L _ { 2 } }$ regularization or weight decay regularization to train deep neural networks with SGD and Adam. We show that a major factor of the poor generalization of the most popular adaptive gradient method, Adam, is due to the fact that $\mathrm { L _ { 2 } }$ regularization is not nearly as effective for it as for SGD. Specifically, our analysis of Adam leads to the following observations:
+
+$\mathbf { L } _ { 2 }$ regularization and weight decay are not identical. Contrary to a belief which seems popular among some practitioners, the two techniques are not equivalent. For SGD, they can be made equivalent by a reparameterization of the weight decay factor based on the learning rate; this is not the case for Adam. In particular, when combined with adaptive gradients, $\mathrm { L _ { 2 } }$ regularization leads to weights with large parameter and/or gradient amplitudes being regularized less than they would be when using weight decay.
+
+$\mathbf { L } _ { 2 }$ regularization is not effective in Adam. One possible explanation why Adam and other adaptive gradient methods might be outperformed by SGD with momentum is that common deep learning libraries only implement $\mathrm { L _ { 2 } }$ regularization, not the original weight decay. Therefore, on tasks/datasets where the use of $\mathrm { L _ { 2 } }$ regularization is beneficial for SGD (e.g., on many popular image classification datasets), Adam leads to worse results than SGD with momentum (for which $\mathrm { L _ { 2 } }$ regularization behaves as expected).
+
+Weight decay is equally effective in both SGD and Adam. For SGD, it is equivalent to $\mathrm { L _ { 2 } }$ regularization, while for Adam it is not.
+
+Optimal weight decay depends on the total number of batch passes/weight updates. Our empirical analysis of SGD and Adam suggests that the larger the runtime/number of batch passes to be performed, the smaller the optimal weight decay. This effect tends to be neglected because hyperparameters are often tuned for a fixed number of training epochs. As a result, the values of the weight decay found to perform best for short runs do not generalize to much longer runs.
+
+The main contribution of this paper is to improve regularization in Adam by decoupling the weight decay from the gradient-based update. In a comprehensive analysis, we show that Adam generalizes substantially better with decoupled weight decay than with $\mathrm { L _ { 2 } }$ regularization, achieving $15 \%$ relative improvement in test error (see Figures 2 and 3); this holds true for various image recognition datasets (CIFAR-10 and ImageNet32x32), training budgets (ranging from 100 to 1800 epochs), and learning rate schedules (fixed, drop-step, and cosine annealing; see Figure 1). We demonstrate that our decoupled weight decay renders the optimal settings of the learning rate and the weight decay factor much more independent, thereby easing hyperparameter optimization (see Figure 2).
+
+The main motivation of this paper is to improve Adam to make it competitive w.r.t. SGD with momentum even for those problems where it did not use to be competitive. We hope that as a result, practitioners do not need to switch between Adam and SGD anymore, which in turn should reduce the common issue of selecting dataset/task-specific training algorithms and their hyperparameters.
+
+2 DECOUPLING THE WEIGHT DECAY FROM THE GRADIENT-BASED UPDATE
+
+In the weight decay described by Hanson & Pratt (1988), the weights $\pmb \theta$ decay exponentially as
+
+$$
+\pmb { \theta } _ { t + 1 } = ( 1 - \lambda ) \pmb { \theta } _ { t } - \alpha \nabla f _ { t } ( \pmb { \theta } _ { t } ) ,
+$$
+
+where $\lambda$ defines the rate of the weight decay per step and $\nabla f _ { t } ( \pmb { \theta } _ { t } )$ is the $t$ -th batch gradient to be multiplied by a learning rate $\alpha$ . For standard SGD, it is equivalent to standard $\mathrm { L _ { 2 } }$ regularization:
+
+Proposition 1 (Weight decay ${ \bf \tau } = { \bf L } _ { 2 }$ reg for standard SGD). Standard SGD with base learning rate $\alpha$ executes the same steps on batch loss functions $f _ { t } ( \pmb \theta )$ with weight decay $\lambda$ (defined in Equation $I$ ) as it executes without weight decay on $\begin{array} { r } { f _ { t } ^ { r e g } ( { \pmb { \theta } } ) = f _ { t } ( { \pmb { \theta } } ) + \frac { \lambda ^ { \prime } } { 2 } \left\| { \pmb { \theta } } \right\| _ { 2 } ^ { 2 } } \end{array}$ , with $\begin{array} { r } { \lambda ^ { \prime } = \frac { \lambda } { \alpha } } \end{array}$ .
+
+The proofs of this well-known fact, as well as our other propositions, are given in the Appendix A.
+
+Due to this equivalence, $\mathrm { L _ { 2 } }$ regularization is very frequently referred to as weight decay, including in popular deep learning libraries. However, as we will demonstrate later in this section, this equivalence does not hold for adaptive gradient methods. One fact that is often overlooked already for the simple case of SGD is that in order for the equivalence to hold, the $\mathrm { L _ { 2 } }$ regularizer $\lambda ^ { \prime }$ has to be set to $\frac { \lambda } { \underset { \mathbf { x } } { \alpha } }$ , i.e., if there ie learning rate n overall best weight decay value . In order to decouple the effects $\lambda$ , the best value of  these two hyperp $\lambda ^ { \prime }$ is tightly coupled withmeters, we advocate to $\alpha$ decouple the weight decay step as proposed by Hanson & Pratt (1988) (Equation 1).
+
+Looking first at the case of SGD, we propose to decay the weights simultaneously with the update of $\theta _ { t }$ based on gradient information in Line 9 of Algorithm 1. This yields our proposed variant of SGD with momentum using decoupled weight decay (SGDW). This simple modification explicitly decouples $\lambda$ and $\alpha$ (although some problem-dependent implicit coupling may of course remain as for any two hyperparameters). In order to account for a possible scheduling of both $\alpha$ and $\lambda$ , we introduce a scaling factor $\eta _ { t }$ delivered by a user-defined procedure SetScheduleMultiplier $( t )$ .
+
+Now, let’s turn to adaptive gradient algorithms like the popular optimizer Adam Kingma & Ba (2014), which scale gradients by their historic magnitudes. Intuitively, when Adam is run on a loss function $f$ plus $\mathrm { L _ { 2 } }$ regularization, weights that tend to have large gradients in $f$ do not get regularized as much as they would with decoupled weight decay, since the gradient of the regularizer gets scaled along with the gradient of $f$ . This leads to an inequivalence of $\mathrm { L _ { 2 } }$ and decoupled weight decay regularization for adaptive gradient algorithms:
+
+<table><tr><td>Algorithm 1 SGD with L2 regularization</td><td></td><td>SGD with decoupled weight decay (SGDW) both</td></tr><tr><td>with momentum</td><td colspan="2"></td></tr></table>
+
+1: given initial learning rate $\alpha \in \mathbb { R }$ , momentum factor $\beta _ { 1 } \in \mathbb { R }$ , weight decay/L2 regularization factor $\overline { { \lambda \in \mathbb { R } } }$   
+2: initialize time step $t  0$ , parameter vector $\pmb { \theta } _ { t = 0 } ~ \in ~ \mathbb { R } ^ { n }$ , first moment vector $\pmb { m } _ { t = 0 } \gets \pmb { \theta }$ , schedule   
+multiplier $\eta _ { t = 0 } \in \mathbb { R }$   
+3: repeat   
+4: $t \gets t + 1$   
+5: $\nabla f _ { t } \big ( \pmb { \theta } _ { t - 1 } \big ) \gets \mathrm { S e l e c t B a t c h } \big ( \pmb { \theta } _ { t - 1 } \big )$ . select batch and return the corresponding gradient   
+6: $\pmb { g } _ { t } \gets \nabla f _ { t } ( \pmb { \theta } _ { t - 1 } ) \ + \lambda \pmb { \theta } _ { t - 1 }$   
+7: ηt ← SetScheduleMultiplier(t) . can be fixed, decay, be used for warm restarts   
+8: ${ \pmb { m } } _ { t } \gets \beta _ { 1 } { \pmb { m } } _ { t - 1 } + \eta _ { t } \alpha { \pmb { g } } _ { t }$   
+9: $\pmb { \theta } _ { t } \gets \pmb { \theta } _ { t - 1 } - \pmb { m } _ { t } - \eta _ { t } \lambda \pmb { \theta } _ { t - 1 }$   
+10: until stopping criterion is met   
+11: return optimized parameters ${ \pmb \theta } _ { t }$   
+1: given $\alpha = 0 . 0 0 1 , \beta _ { 1 } = 0 . 9 , \beta _ { 2 } = 0 . 9 9 9 , \epsilon = 1 0 ^ { - 8 } , \lambda \in \mathbb { R }$   
+2: initialize time step $t \gets 0$ , parameter vector $\pmb { \theta } _ { t = 0 } \in \mathbb { R } ^ { n }$ , first moment vector $\pmb { m } _ { t = 0 }  \pmb { \theta }$ , second moment   
+vector $\pmb { \nu } _ { t = 0 }  \pmb { \theta }$ , schedule multiplier $\eta _ { t = 0 } \in \mathbb { R }$   
+3: repeat   
+4: $t \gets t + 1$   
+5: $\nabla f _ { t } (  { \mathbf { \dot { \theta } } } _ { t - 1 } ^ { \phantom { \dagger } } ) \gets \mathrm { S e l e c t B a t c h } (  { \mathbf { \theta } } _ { t - 1 } )$ . select batch and return the corresponding gradient   
+6: $\pmb { \mathscr { g } } _ { t } \gets \nabla f _ { t } ( \pmb { \theta } _ { t - 1 } ) \ + \lambda \pmb { \theta } _ { t - 1 }$   
+7: $\pmb { m } _ { t } \gets \beta _ { 1 } \pmb { m } _ { t - 1 } + ( 1 - \beta _ { 1 } ) \pmb { g } _ { t }$ . here and below all operations are element-wise   
+8: $\pmb { \nu } _ { t } \gets \beta _ { 2 } \pmb { \nu } _ { t - 1 } + ( 1 - \beta _ { 2 } ) \pmb { g } _ { t } ^ { 2 }$   
+9: $\hat { { \pmb { m } } } _ { t } \gets { \pmb { m } } _ { t } / ( 1 - \beta _ { 1 } ^ { t } )$ . $\beta _ { 1 }$ is taken to the power of $t$   
+10: ˆvt ← vt/(1 − βt2) . $\beta _ { 2 }$ is taken to the power of $t$   
+11: $\eta _ { t } \gets$ SetScheduleMultiplier(t) . can be fixed, decay, or also be used for warm restarts   
+12: θt ← θt−1 − ηt αmˆ t/( ˆvt + ) +λθt−1   
+13: until stopping criterion is met
+
+<table><tr><td>Algorithm 2 Adam with L2 regularization</td><td>and</td></tr></table>
+
+14: return optimized parameters ${ \pmb \theta } _ { t }$
+
+Proposition 2 (Weight decay $\neq \mathrm { L } _ { 2 }$ reg for adaptive gradients). Let $O$ denote an optimizer that has iterates $\pmb { \theta } _ { t + 1 }  \pmb { \theta } _ { t } - \alpha \mathbf { M } _ { t } \nabla f _ { t } ( \pmb { \theta } _ { t } )$ when run on batch loss function $f _ { t } ( \pmb \theta )$ without weight decay, and $\pmb { \theta } _ { t + 1 } \gets ( 1 - \lambda ) \pmb { \theta } _ { t } - \alpha \mathbf { M } _ { t } \nabla f _ { t } ( \pmb { \theta } _ { t } )$ when run on $f _ { t } ( \pmb \theta )$ with weight decay, respectively, with $\mathbf { M } _ { t } \neq k \mathbf { I }$ (where $k \in \mathbb { R } ,$ ). Then, for $O$ there exists no $L _ { 2 }$ coefficient $\lambda ^ { \prime }$ such that running $O$ on batch loss $\begin{array} { r } { f _ { t } ^ { r e g } ( { \pmb \theta } ) = f _ { t } ( { \pmb \theta } ) + \frac { \lambda ^ { \prime } } { 2 } \left. { \pmb \theta } \right. _ { 2 } ^ { 2 } } \end{array}$ without weight decay is equivalent to running $O$ on $f _ { t } ( \pmb \theta )$ with decay $\lambda \in \mathbb { R } ^ { + }$ .
+
+We decouple weight decay and loss-based gradient updates in Adam as shown in line 12 of Algorithm 2; this gives rise to our variant of Adam with decoupled weight decay (AdamW).
+
+Having shown that $\mathrm { L _ { 2 } }$ regularization and weight decay regularization differ for adaptive gradient algorithms raises the question of how they differ and how to interpret their effects. Their equivalence for standard SGD remains very helpful for intuition: both mechanisms push weights closer to zero, at the same rate. However, for adaptive gradient algorithms they differ: with $\mathrm { L _ { 2 } }$ regularization, the sums of the gradient of the loss function and the gradient of the regularizer (i.e., the $\mathrm { L _ { 2 } }$ norm of the weights) are adapted, whereas with weight decay, only the gradients of the loss function are adapted (with the weight decay step separated from the adaptive gradient mechanism). With $\mathrm { L _ { 2 } }$ regularization both types of gradients are normalized by their typical (summed) magnitudes, and therefore weights $x$ with large typical gradient magnitude $s$ are regularized by a smaller relative amount than other weights. In contrast, weight decay regularizes all weights with the same rate $\lambda$ , effectively regularizing weights $x$ with large $s$ more than standard $\mathrm { L _ { 2 } }$ regularization does. We demonstrate this formally for a simple special case of adaptive gradient algorithm with a fixed preconditioner:
+
+Proposition 3 (Weight decay $=$ scale-adjusted $L _ { 2 }$ reg for adaptive gradient algorithm with fixed preconditioner). Let $O$ denote an algorithm with the same characteristics as in Proposition 2, and using a fixed preconditioner matrix ${ \bf \bar { \cal M } } _ { t } = d i a g ( s ) ^ { - 1 }$ (with $s _ { i } > 0$ for all $i _ { , }$ ). Then, $O$ with base learning rate $\alpha$ executes the same steps on batch loss functions $f _ { t } ( \pmb \theta )$ with weight decay $\lambda$ as it executes without weight decay on the scale-adjusted regularized batch loss
+
+$$
+f _ { t } ^ { s r e g } ( \pmb { \theta } ) = f _ { t } ( \pmb { \theta } ) + \frac { \lambda ^ { \prime } } { 2 \alpha } \left\| \pmb { \theta } \odot \sqrt { \pmb { s } } \right\| _ { 2 } ^ { 2 } ,
+$$
+
+where $\odot$ and $\sqrt { \cdot }$ denote element-wise multiplication and square root, respectively, and $\begin{array} { r } { \lambda ^ { \prime } = \frac { \lambda } { \alpha } } \end{array}$
+
+# 3 JUSTIFICATION OF DECOUPLED WEIGHT DECAY VIA A VIEW OF ADAPTIVE GRADIENT METHODS AS BAYESIAN FILTERING
+
+We now discuss a justification of decoupled weight decay in the framework of Bayesian filtering for a unified theory of adaptive gradient algorithms due to Aitchison (2018). After we posted a preliminary version of our current paper on arXiv, Aitchison noted that his theory “gives us a theoretical framework in which we can understand the superiority of this weight decay over $L _ { 2 }$ regularization, because it is weight decay, rather than $L _ { 2 }$ regularization that emerges through the straightforward application of Bayesian filtering.”(Aitchison, 2018). While full credit for this theory goes to Aitchison, we summarize it here to shed some light on why weight decay may be favored over $L _ { 2 }$ regularization.
+
+Aitchison (2018) views stochastic optimization of $n$ parameters $x _ { 1 } , \ldots , x _ { n }$ as a Bayesian filtering problem with the goal of inferring a distribution over the optimal values of each of the parameters $x _ { i }$ given the current values of the other parameters $\pmb \theta _ { - i } ( t )$ at time step $t$ . When the other parameters do not change this is an optimization problem, but when they do change it becomes one of “tracking” the optimizer using Bayesian filtering as follows. One is given a probability distribution $\bar { P ( \pmb \theta _ { t } ) } \ |$ $y _ { 1 : t } )$ of the optimizer at time step $t$ that takes into account the data $\scriptstyle { \boldsymbol { y } } _ { 1 : t }$ from the first $t$ mini batches, a state transition prior $P ( \pmb \theta _ { t + 1 } \mid \pmb \theta _ { t } )$ reflecting a (small) data-independent change in this distribution from one step to the next, and a likelihood $\mathbf { \bar { \ u } } _ { P ( \pmb { y } _ { t + 1 } \mid \mathbf { \theta } _ { t + 1 } ) }$ derived from the mini batch at step $t + 1$ . The posterior distribution $P ( \pmb { \theta } _ { t + 1 } \mid \mathbf { y } _ { 1 : t + 1 } )$ of the optimizer at time step $t + 1$ can then be computed (as usual in Bayesian filtering) by marginalizing over $\theta _ { t }$ to obtain the onestep ahead predictions $P ( \pmb { \theta } _ { t + 1 } \mid \pmb { y } _ { 1 : t } )$ and then applying Bayes’ rule to incorporate the likelihood $\textstyle P ( \mathbf { \bar { y } } _ { t + 1 } \mid \theta _ { t + 1 } )$ . Aitchison (2018) assumes a Gaussian state transition distribution $P ( \pmb \theta _ { t + 1 } \mid \pmb \theta _ { t } )$ and an approximate conjugate likelihood $\textstyle P ( \pmb { y } _ { t + 1 } \mid \pmb { \theta } _ { t + 1 } )$ , leading to the following closed-form update of the filtering distribution’s mean:
+
+$$
+\begin{array} { r } { \pmb { \mu } _ { p o s t } = \pmb { \mu } _ { p r i o r } + \pmb { \Sigma } _ { p o s t } \times \pmb { g } , } \end{array}
+$$
+
+where $\textbf {  { g } }$ is the gradient of the log likelihood of the mini batch at time $t$ . This result implies a preconditioner of the gradients that is given by the posterior uncertainty $\Sigma _ { p o s t }$ of the filtering distribution: updates are larger for parameters we are more uncertain about and smaller for parameters we are more certain about. Aitchison (2018) goes on to show that popular adaptive gradient methods, such as Adam and RMSprop, as well as Kronecker-factorized methods are special cases of this framework.
+
+Decoupled weight decay very naturally fits into this unified framework can express weight decay as part of the state-transition distribution: Aitchison (2018) assumes a slow change of the optimizer according to the following Gaussian:
+
+$$
+P ( \pmb \theta _ { t + 1 } \mid \pmb \theta _ { t } ) = N ( ( \pmb I - \pmb A ) \pmb \theta _ { t } , \pmb Q ) ,
+$$
+
+where $Q$ is the covariance of Gaussian perturbations of the weights, and $\pmb { A }$ is a regularizer to avoid values growing unboundedly over time. When instantiated as $A = \lambda \times I$ , this regularizer $\pmb { A }$ plays exactly the role of decoupled weight decay as described in Equation 1, since this leads to multiplying the current mean estimate $\theta _ { t }$ by $( 1 - \lambda )$ at each step. Notably, this regularization is also directly applied to the prior and does not depend on the uncertainty in each of the parameters (which would be required for $L _ { 2 }$ regularization).
+
+![](images/cdc01f838cc870b7893f2bd8b1b4fdadd1d0ed078db65ddff2d8aef49b319780.jpg)  
+Figure 1: Adam performs better with decoupled weight decay (bottom row, AdamW) than with $L _ { 2 }$ regularization (top row, Adam). We show the final test error of a $2 6 ~ 2 \mathrm { x } 6 4 \mathrm { d }$ ResNet on CIFAR-10 after 100 epochs of training with fixed learning rate (left column), step-drop learning rate (with drops at epoch indexes 30, 60 and 80, middle column) and cosine annealing (right column). AdamW leads to a more separable hyperparameter search space, especially when a learning rate schedule, such as step-drop and cosine annealing is applied. Cosine annealing yields clearly superior results.
+
+# 4 EXPERIMENTAL VALIDATION
+
+We now evaluate the performance of decoupled weight decay under various training budgets and learning rate schedules. Our experimental setup follows that of Gastaldi (2017), who proposed, in addition to $\mathrm { L _ { 2 } }$ regularization, to apply the new Shake-Shake regularization to a 3-branch residual DNN that allowed to achieve new state-of-the-art results of $2 . 8 6 \%$ on the CIFAR-10 dataset (Krizhevsky, 2009). We always used a batch size of 128. The regular data augmentation procedure used for the CIFAR datasets was applied. We used the same model/source code based on fb.resnet.torch 1. The base networks are a $2 6 ~ 2 \mathrm { x } 6 4 \mathrm { d }$ ResNet (i.e. the network has a depth of 26, 2 residual branches and the first residual block has a width of 64) and a $2 6 2 \mathrm { x } 9 6 \mathrm { d }$ ResNet with $1 1 . 6 \mathbf { M }$ and $2 5 . 6 \mathbf { M }$ parameters, respectively. For a detailed description of the network and the Shake-Shake method, we refer the interested reader to Gastaldi (2017). We also perform experiments on the ImageNet32x32 dataset (Chrabaszcz et al., 2017), a downsampled version of the original ImageNet dataset with 1.2 million $3 2 \times 3 2$ pixels images.
+
+# 4.1 EVALUATING DECOUPLED WEIGHT DECAY WITH DIFFERENT LEARNING RATE SCHEDULES
+
+In our first experiment, we compare Adam with $L _ { 2 }$ regularization to Adam with decoupled weight decay (AdamW), using three different learning rate schedules: a fixed learning rate, a drop-step schedule, and a cosine annealing schedule (Loshchilov & Hutter, 2016). For each learning rate schedule and weight decay variant, we trained a 2x64d ResNet for 100 epochs, using different settings of the initial learning rate $\alpha$ and the weight decay factor $\lambda$ . Figure 1 shows that decoupled weight decay outperforms $L _ { 2 }$ regularization for all learning rate schedules, with larger differences for better learning rate schedules. We also note that decoupled weight decay leads to a more separable hyperparameter search space, especially when a learning rate schedule, such as step-drop and cosine annealing is applied. The figure also shows that cosine annealing clearly outperforms the other learning rate schedules; we thus used cosine annealing for the remainder of the experiments.
+
+![](images/912ae7b475cea2253f76582036e0793936fecf71a117beab28917bbc8e28d712.jpg)  
+Figure 2: The Top-1 test error of a 26 2x64d ResNet on CIFAR-10 measured after 100 epochs. The proposed SGDW and AdamW (right column) have a more separable hyperparameter space.
+
+![](images/ebfc9d3556d4d95c8aaba3765fe521f34e36b21c331fc769c98b81b49d5fe39f.jpg)  
+Figure 3: Learning curves (top row) and generalization results (bottom row) obtained by a 26 $2 \mathrm { x } 9 6 \mathrm { d }$ ResNet trained with Adam and AdamW on CIFAR-10. See text for details. SuppFigure 4 in the Appendix shows the same qualitative results for ImageNet $3 2 \mathbf { x } 3 2$ .
+
+4.2 DECOUPLING THE WEIGHT DECAY AND INITIAL LEARNING RATE PARAMETERS
+
+In order to verify our hypothesis about the coupling of $\alpha$ and $\lambda$ , in Figure 2 we compare the performance of $\mathrm { L _ { 2 } }$ regularization vs. decoupled weight decay in SGD (SGD vs. SGDW, top row) and in Adam (Adam vs. AdamW, bottom row). In SGD (Figure 2, top left), $\mathrm { L _ { 2 } }$ regularization is not decoupled from the learning rate (the common way as described in Algorithm 1), and the figure clearly shows that the basin of best hyperparameter settings (depicted by color and top-10 hyperparameter settings by black circles) is not aligned with the $\mathbf { X }$ -axis or y-axis but lies on the diagonal. This suggests that the two hyperparameters are interdependent and need to be changed simultaneously, while only changing one of them might substantially worsen results. Consider, e.g., the setting at the top left black circle $( \alpha = 1 / 2$ , $\lambda \overset { - } { = } 1 / 8 * 0 . 0 0 1 )$ ; only changing either $\alpha$ or $\lambda$ by itself would worsen results, while changing both of them could still yield clear improvements. We note that this coupling of initial learning rate and $\mathrm { L _ { 2 } }$ regularization factor might have contributed to SGD’s reputation of being very sensitive to its hyperparameter settings.
+
+In contrast, the results for SGD with decoupled weight decay (SGDW) in Figure 2 (top right) show that weight decay and initial learning rate are decoupled. The proposed approach renders the two hyperparameters more separable: even if the learning rate is not well tuned yet (e.g., consider the value of 1/1024 in Figure 2, top right), leaving it fixed and only optimizing the weight decay factor would yield a good value (of $1 / 4 ^ { * } 0 . 0 0 1$ ). This is not the case for SGD with $\mathrm { L _ { 2 } }$ regularization (see Figure 2, top left).
+
+The results for Adam with $\mathrm { L _ { 2 } }$ regularization are given in Figure 2 (bottom left). Adam’s best hyperparameter settings performed clearly worse than SGD’s best ones (compare Figure 2, top left). While both methods used $\mathrm { L _ { 2 } }$ regularization, Adam did not benefit from it at all: its best results obtained for non-zero $\mathrm { L _ { 2 } }$ regularization factors were comparable to the best ones obtained without the $\mathrm { L _ { 2 } }$ regularization, i.e., when $\lambda = 0$ . Similarly to the original SGD, the shape of the hyperparameter landscape suggests that the two hyperparameters are coupled.
+
+In contrast, the results for our new variant of Adam with decoupled weight decay (AdamW) in Figure 2 (bottom right) show that AdamW largely decouples weight decay and learning rate. The results for the best hyperparameter settings were substantially better than the best ones of Adam with $\mathrm { L _ { 2 } }$ regularization and rivaled those of SGD and SGDW.
+
+In summary, the results in Figure 2 support our hypothesis that the weight decay and learning rate hyperparameters can be decoupled, and that this in turn simplifies the problem of hyperparameter tuning in SGD and improves Adam’s performance to be competitive w.r.t. SGD with momentum.
+
+# 4.3 BETTER GENERALIZATION OF ADAMW
+
+While the previous experiment suggested that the basin of optimal hyperparameters of AdamW is broader and deeper than the one of Adam, we next investigated the results for much longer runs of 1800 epochs to compare the generalization capabilities of AdamW and Adam.
+
+We fixed the initial learning rate to 0.001 which represents both the default learning rate for Adam and the one which showed reasonably good results in our experiments. Figure 3 shows the results for 12 settings of the $\mathrm { L _ { 2 } }$ regularization of Adam and 7 settings of the normalized weight decay of AdamW (the normalized weight decay represents a rescaling formally defined in the Appendix B.1, it amounts to a multiplicative factor which depends on the number of bath passes). Interestingly, while the dynamics of the learning curves of Adam and AdamW often coincided for the first half of the training run, AdamW often led to lower training loss and test errors (see Figure 3 top left and top right, respectively). Importantly, the use of weight decay in Adam did not yield as good results as in AdamW (see also Figure 3, bottom left). Next, we investigated whether AdamW’s better results were only due to better convergence or due to better generalization. The results in Figure 3 (bottom right) for the best settings of Adam and AdamW suggest that AdamW did not only yield better training loss but also yielded better generalization performance for similar training loss values. The results on ImageNet32x32 (see SuppFigure 4 in the Appendix) lead to the same conclusion of substantially improved generalization performance.
+
+![](images/601a579961d1f5b8ba84aa32ca7fd5710ad12c354741ccbf24164731e477145b.jpg)  
+Figure 4: Top-1 test error on CIFAR-10 (left) and Top-5 test error on ImageNet32x32 (right). For a better resolution and with training loss curves, see SuppFigure 5 and SuppFigure 6 in the supplementary material.
+
+# 4.4 ADAMWR WITH WARM RESTARTS FOR BETTER ANYTIME PERFORMANCE
+
+In order to improve anytime performance of SGDW and AdamW we extended them with warm restarts of (Loshchilov & Hutter, 2016) to obtain SGDWR and AdamWR, respectively (see section B.2 in the Appendix). As Figure 4 shows, AdamWR greatly sped up AdamW on CIFAR-10 and ImageNet32x32, up to a factor of 10 (see the results at the first restart). For the default learning rate of 0.001, AdamW achieved $1 5 \%$ relative improvement in test errors compared to Adam both on CIFAR-10 (also see Figure 3) and ImageNet $3 2 x 3 2$ (also see SuppFigure 5). AdamWR achieved the same improved results but with a much better anytime performance. These improvements closed most of the gap between Adam and SGDWR on CIFAR-10 and yielded comparable performance on ImageNet32x32.
+
+# 4.5 USE OF ADAMW ON OTHER DATASETS AND ARCHITECTURES
+
+Several other research groups have already successfully applied AdamW in citable works. For example, Wang et al. (2018) used AdamW to train a novel architecture for face detection on the standard WIDER FACE dataset (Yang et al., 2016), obtaining almost 10x faster predictions than the previous state of the art algorithms while achieving comparable performance. Volker et al. (2018) employed ¨ AdamW with cosine annealing to train convolutional neural networks to classify and characterize error-related brain signals measured from intracranial electroencephalography (EEG) recordings. While their paper does not provide a comparison to Adam, they kindly provided us with a direct comparison of the two on their best-performing problem-specific network architecture Deep4Net and a variant of ResNet. AdamW with the same hyperparameter setting as Adam yielded higher test set accuracy on Deep4Net $7 3 . 6 8 \%$ versus $7 1 . 3 7 \%$ ) and statistically significantly higher test set accuracy on ResNet $( 7 2 . 0 4 \%$ versus $6 1 . 3 4 \%$ . Radford et al. (2018) employed AdamW to train Transformer (Vaswani et al., 2017) architectures to obtain new state-of-the-art results on a wide range of benchmarks for natural language understanding. Zhang et al. (2018) compared $\mathrm { L _ { 2 } }$ regularization vs. weight decay for SGD, Adam and the Kronecker-Factored Approximate Curvature (K-FAC) optimizer (Martens & Grosse, 2015) on the CIFAR datasets with ResNet and VGG architectures, reporting that decoupled weight decay consistently outperformed $\mathrm { L _ { 2 } }$ regularization in cases where they differ.
+
+# 5 CONCLUSION AND FUTURE WORK
+
+Following suggestions that adaptive gradient methods such as Adam might lead to worse generalization than SGD with momentum (Wilson et al., 2017), we identified and exposed the inequivalence of $\mathrm { L _ { 2 } }$ regularization and weight decay for Adam. We empirically showed that our version of Adam with decoupled weight decay yields substantially better generalization performance than the common implementation of Adam with $\mathrm { L _ { 2 } }$ regularization. We also proposed to use warm restarts for Adam to improve its anytime performance.
+
+Our results obtained on image classification datasets must be verified on a wider range of tasks, especially ones where the use of regularization is expected to be important. It would be interesting to integrate our findings on weight decay into other methods which attempt to improve Adam, e.g, normalized direction-preserving Adam (Zhang et al., 2017). While we focused our experimental analysis on Adam, we believe that similar results also hold for other adaptive gradient methods, such as AdaGrad (Duchi et al., 2011) and AMSGrad (Reddi et al., 2018).
+
+# 6 ACKNOWLEDGMENTS
+
+This work was supported by the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme under grant no. 716721, by the German Research Foundation (DFG), under the BrainLinksBrainTools Cluster of Excellence (grant number EXC 1086) and through grant no. INST 37/935-1 FUGG, and by the German state of BadenWurttemberg through bwHPC. We thank Patryk Chrabaszcz for helping running experiments with ¨ ImageNet32x32. We thank Matthias Feurer and Robin Schirrmeister for providing valuable feedback on this paper in several iterations. We thank Martin Volker, Robin Schirrmeister, and Tonio ¨ Ball for providing us with a comparison of AdamW and Adam on their EEG data.
+
+Finally, we thank the following members of the deep learning community for implementing decoupled weight decay in various deep learning libraries:
+
+• Jingwei Zhang, Lei Tai, Robin Schirrmeister, and Kashif Rasul for their implementations in PyTorch (see https://github.com/pytorch/pytorch/pull/4429)   
+• Phil Jund for his implementation in TensorFlow described at https://www.tensorflow.org/api_docs/python/tf/contrib/opt/ DecoupledWeightDecayExtension Sylvain Gugger, Anand Saha, Jeremy Howard and other members of fast.ai for their implementation available at https://github.com/sgugger/Adam-experiments Guillaume Lambard for his implementation in Keras available at https://github. com/GLambard/AdamW_Keras   
+• Yagami Lin for his implementation in Caffe available at https://github.com/ Yagami123/Caffe-AdamW-AdamWR
+
+# REFERENCES
+
+Laurence Aitchison. A unified theory of adaptive stochastic gradient descent as Bayesian filtering. arXiv:1507.02030, 2018.
+
+Patryk Chrabaszcz, Ilya Loshchilov, and Frank Hutter. A downsampled variant of ImageNet as an alternative to the CIFAR datasets. arXiv:1707.08819, 2017.
+
+Ekin D Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V Le. Autoaugment: Learning augmentation policies from data. arXiv preprint arXiv:1805.09501, 2018.
+
+Laurent Dinh, Razvan Pascanu, Samy Bengio, and Yoshua Bengio. Sharp minima can generalize for deep nets. arXiv:1703.04933, 2017.
+
+John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. The Journal of Machine Learning Research, 12:2121–2159, 2011.
+
+Xavier Gastaldi. Shake-Shake regularization. arXiv preprint arXiv:1705.07485, 2017.
+
+Stephen Jose Hanson and Lorien Y Pratt. Comparing biases for minimal network construction with ´ back-propagation. In Proceedings of the 1st International Conference on Neural Information Processing Systems, pp. 177–185, 1988.
+
+Gao Huang, Yixuan Li, Geoff Pleiss, Zhuang Liu, John E Hopcroft, and Kilian Q Weinberger. Snapshot ensembles: Train 1, get m for free. arXiv:1704.00109, 2017.
+
+Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv:1609.04836, 2016.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv:1412.6980, 2014.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009.
+
+Hao Li, Zheng Xu, Gavin Taylor, and Tom Goldstein. Visualizing the loss landscape of neural nets. arXiv preprint arXiv:1712.09913, 2017.
+
+Ilya Loshchilov and Frank Hutter. SGDR: stochastic gradient descent with warm restarts. arXiv:1608.03983, 2016.
+
+James Martens and Roger Grosse. Optimizing neural networks with kronecker-factored approximate curvature. In International conference on machine learning, pp. 2408–2417, 2015.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv:1511.06434, 2015.
+
+Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training. URL https://s3-us-west-2. amazonaws. com/openaiassets/research-covers/language-unsupervised/language understanding paper. pdf, 2018.
+
+Sashank J. Reddi, Satyen Kale, and Sanjiv Kumar. On the convergence of adam and beyond. Inter national Conference on Learning Representations, 2018.
+
+Leslie N Smith. Cyclical learning rates for training neural networks. arXiv:1506.01186v3, 2016.
+
+Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural networks for machine learning, 4(2):26– 31, 2012.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017.
+
+Martin Volker, Ji ¨ ˇr´ı Hammer, Robin T Schirrmeister, Joos Behncke, Lukas DJ Fiederer, Andreas Schulze-Bonhage, Petr Marusic, Wolfram Burgard, and Tonio Ball. Intracranial error detection ˇ via deep learning. arXiv preprint arXiv:1805.01667, 2018.
+
+Jianfeng Wang, Ye Yuan, Gang Yu, and Sun Jian. Sface: An efficient network for face detection in large scale variations. arXiv preprint arXiv:1804.06559, 2018.
+
+Ashia C Wilson, Rebecca Roelofs, Mitchell Stern, Nathan Srebro, and Benjamin Recht. The marginal value of adaptive gradient methods in machine learning. arXiv:1705.08292, 2017.
+
+Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhudinov, Rich Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In International Conference on Machine Learning, pp. 2048–2057, 2015.
+
+Shuo Yang, Ping Luo, Chen-Change Loy, and Xiaoou Tang. Wider face: A face detection benchmark. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5525–5533, 2016.
+
+Guodong Zhang, Chaoqi Wang, Bowen Xu, and Roger Grosse. Three mechanisms of weight decay regularization. arXiv preprint arXiv:1810.12281, 2018.
+
+Zijun Zhang, Lin Ma, Zongpeng Li, and Chuan Wu. Normalized direction-preserving adam. arXiv:1709.04546, 2017.
+
+Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V. Le. Learning transferable architectures for scalable image recognition. In arXiv:1707.07012 [cs.CV], 2017.
+
+# Appendix
+
+A FORMAL ANALYSIS OF WEIGHT DECAY VS $\mathrm { L _ { 2 } }$ REGULARIZATION
+
+# Proof of Proposition 1
+
+The proof for this well-known fact is straight-forward. SGD without weight decay has the following iterates on $\begin{array} { r } { f _ { t } ^ { \mathrm { r e g } } ( { \pmb \theta } ) = f _ { t } ( { \pmb \theta } ) + \frac { \lambda ^ { \prime } } { 2 } \left\| { \pmb \theta } \right\| _ { 2 } ^ { 2 } } \end{array}$ :
+
+$$
+\pmb { \theta } _ { t + 1 }  \pmb { \theta } _ { t } - \alpha \nabla f _ { t } ^ { \mathrm { r e g } } ( \pmb { \theta } _ { t } ) = \pmb { \theta } _ { t } - \alpha \nabla f _ { t } ( \pmb { \theta } _ { t } ) - \alpha \lambda ^ { \prime } \pmb { \theta } _ { t } .
+$$
+
+SGD with weight decay has the following iterates on $f _ { t } ( \pmb \theta )$ :
+
+$$
+\pmb { \theta } _ { t + 1 }  ( 1 - \lambda ) \pmb { \theta } _ { t } - \alpha \nabla f _ { t } ( \pmb { \theta } _ { t } ) .
+$$
+
+These iterates are identical since $\begin{array} { r } { \lambda ^ { \prime } = \frac { \lambda } { \alpha } } \end{array}$
+
+# Proof of Proposition 2
+
+Similarly to the Proof of Proposition 1, the iterates of $O$ without weight decay on $f _ { t } ^ { \mathrm { r e g } } ( { \pmb \theta } ) = f _ { t } ( { \pmb \theta } ) +$ $\begin{array} { r } { \frac { 1 } { 2 } \lambda ^ { \prime } \left. \pmb { \theta } \right. _ { 2 } ^ { 2 } } \end{array}$ and $O$ with weight decay $\lambda$ on $f _ { t }$ are, respectively:
+
+$$
+\begin{array} { l l l } { \pmb { \theta } _ { t + 1 } } & {  } & { \pmb { \theta } _ { t } - \alpha \lambda ^ { \prime } \mathbf { M } _ { t } \pmb { \theta } _ { t } - \alpha \mathbf { M } _ { t } \nabla f _ { t } ( \pmb { \theta } _ { t } ) . } \\ { \pmb { \theta } _ { t + 1 } } & {  } & { ( 1 - \lambda ) \pmb { \theta } _ { t } - \alpha \mathbf { M } _ { t } \nabla f _ { t } ( \pmb { \theta } _ { t } ) . } \end{array}
+$$
+
+The equality of these iterates for all $\theta _ { t }$ would imply $\lambda \pmb { \theta } _ { t } = \alpha \lambda ^ { \prime } \mathbf { M } _ { t } \pmb { \theta } _ { t }$ . This can only hold for all $\theta _ { t }$ if $\mathbf { M } _ { t } = k \mathbf { I }$ , with $k \in \mathbb { R }$ , which is not the case for $O$ . Therefore, no $\mathrm { L _ { 2 } }$ regularizer $\lambda ^ { \prime } \left\| \pmb { \theta } \right\| _ { 2 } ^ { 2 }$ exists that makes the iterates equivalent. □
+
+# Proof of Proposition 3
+
+$O$ without weight decay has the following iterates on $\begin{array} { r } { f _ { t } ^ { \mathrm { s r e g } } ( \pmb { \theta } ) = f _ { t } ( \pmb { \theta } ) + \frac { \lambda ^ { \prime } } { 2 } \left\| \pmb { \theta } \odot \sqrt { s } \right\| _ { 2 } ^ { 2 } ; } \end{array}$
+
+$$
+\begin{array} { r c l } { \pmb { \theta } _ { t + 1 } } & {  } & { \pmb { \theta } _ { t } - \alpha \nabla f _ { t } ^ { \mathrm { s r e g } } ( \pmb { \theta } _ { t } ) / s } \\ & { = } & { \pmb { \theta } _ { t } - \alpha \nabla f _ { t } ( \pmb { \theta } _ { t } ) / s - \alpha \lambda ^ { \prime } \pmb { \theta } _ { t } \odot s / s } \\ & { = } & { \pmb { \theta } _ { t } - \alpha \nabla f _ { t } ( \pmb { \theta } _ { t } ) / s - \alpha \lambda ^ { \prime } \pmb { \theta } _ { t } , } \end{array}
+$$
+
+where the division by $\pmb { S }$ is element-wise. $O$ with weight decay has the following iterates on $f _ { t } ( \pmb \theta )$ :
+
+$$
+\begin{array} { r l r } { \pmb { \theta } _ { t + 1 } } & {  } & { ( 1 - \lambda ) \pmb { \theta } _ { t } - \alpha \nabla f ( \pmb { \theta } _ { t } ) / s } \\ & { = } & { \pmb { \theta } _ { t } - \alpha \nabla f ( \pmb { \theta } _ { t } ) / s - \lambda \pmb { \theta } _ { t } , } \end{array}
+$$
+
+These iterates are identical since $\begin{array} { r } { \lambda ^ { \prime } = \frac { \lambda } { \alpha } } \end{array}$ .
+
+# B ADDITIONAL PRACTICAL IMPROVEMENTS OF ADAM
+
+Having discussed decoupled weight decay for improving Adam’s generalization, in this section we introduce two additional components to improve Adam’s performance in practice.
+
+# B.1 NORMALIZED WEIGHT DECAY
+
+Our preliminary experiments showed that different weight decay factors are optimal for different computational budgets (defined in terms of the number of batch passes). Relatedly, Li et al. (2017) demonstrated that a smaller batch size (for the same total number of epochs) leads to the shrinking effect of weight decay being more pronounced. Here, we propose to reduce this dependence by normalizing the values of weight decay. Specifically, we replace the hyperparameter $\lambda$ by a new (more robust) normalized weight decay hyperparameter $\lambda _ { n o r m }$ , and use this to set $\lambda$ as $\begin{array} { r } { \lambda = \lambda _ { n o r m } \sqrt { \frac { b } { B T } } } \end{array}$ , where $b$ is the batch size, $B$ is the total number of training points and $T$ is the total number of epochs.2 Thus, $\lambda _ { n o r m }$ can be interpreted as the weight decay used if only one batch pass is allowed. We emphasize that our choice of normalization is merely one possibility informed by few experiments; a more lasting conclusion we draw is that using some normalization can substantially improve results.
+
+# B.2 ADAM WITH COSINE ANNEALING AND WARM RESTARTS
+
+We now apply cosine annealing and warm restarts to Adam, following the recent work of Loshchilov & Hutter (2016). There, the authors proposed Stochastic Gradient Descent with Warm Restarts (SGDR) to improve anytime performance of SGD by quickly cooling down the learning rate according to a cosine schedule and periodically increasing it. SGDR has been successfully adopted to lead to new state-of-the-art results for popular image classification benchmarks (Huang et al., 2017; Gastaldi, 2017; Zoph et al., 2017), and we therefore tried extending it to Adam. However, while our initial version of Adam with warm restarts had better anytime performance than Adam, it was not competitive with SGD with warm restarts, precisely because $\mathrm { L _ { 2 } }$ regularization was not working as well as in SGD. Now, having fixed this issue by means of the original weight decay regularization (Section 2) and also having introduced normalized weight decay (Section B.1), the original work on cosine annealing and warm restarts by Loshchilov & Hutter (2016) directly carries over to Adam.
+
+In the interest of keeping the presentation self-contained, we briefly describe how SGDR schedules the change of the effective learning rate in order to accelerate the training of DNNs. Here, we decouple the initial learning rate $\alpha$ and its multiplier $\eta _ { t }$ used to obtain the actual learning rate at iteration $t$ (see, e.g., line 8 in Algorithm 1). In SGDR, we simulate a new warm-started run/restart of SGD once $T _ { i }$ epochs are performed, where $i$ is the index of the run. Importantly, the restarts are not performed from scratch but emulated by increasing $\eta _ { t }$ while the old value of $\theta _ { t }$ is used as an initial solution. The amount by which $\eta _ { t }$ is increased controls to which extent the previously acquired information (e.g., momentum) is used. Within the $i$ -th run, the value of $\eta _ { t }$ decays according to a cosine annealing (Loshchilov & Hutter, 2016) learning rate for each batch as follows:
+
+$$
+\eta _ { t } = \eta _ { m i n } ^ { ( i ) } + 0 . 5 ( \eta _ { m a x } ^ { ( i ) } - \eta _ { m i n } ^ { ( i ) } ) ( 1 + \cos ( \pi T _ { c u r } / T _ { i } ) ) ,
+$$
+
+where η min and $\eta _ { m a x } ^ { ( i ) }$ are ranges for the multiplier and $T _ { c u r }$ accounts for how many epochs have been performed since the last restart. $T _ { c u r }$ is updated at each batch iteration $t$ and is thus not constrained to integer values. Adjusting (e.g., decreasing) $\eta _ { m i n } ^ { ( i ) }$ and $\eta _ { m a x } ^ { ( i ) }$ at every $i$ -th restart (see also Smith (2016)) could potentially improve performance, but we do not consider that option here because it would involve additional hyperparameters. For $\eta _ { m a x } ^ { ( i ) } = 1$ = 1 and η(i)min $\eta _ { m i n } ^ { ( i ) } = 0$ , one can simplify Eq. (14) to
+
+$$
+\eta _ { t } = 0 . 5 + 0 . 5 \cos ( \pi T _ { c u r } / T _ { i } ) .
+$$
+
+In order to achieve good anytime performance, one can start with an initially small $T _ { i }$ (e.g., from $1 \%$ to $10 \%$ of the expected total budget) and multiply it by a factor of $T _ { m u l t }$ (e.g., $T _ { m u l t } = 2$ ) at every restart. The $( i + 1 )$ -th restart is triggered when $T _ { c u r } = T _ { i }$ by setting $T _ { c u r }$ to 0. An example setting of the schedule multiplier is given in C.
+
+Our proposed AdamWR algorithm represents AdamW (see Algorithm 2) with $\eta _ { t }$ following Eq. (15) and $\lambda$ computed at each iteration using normalized weight decay described in the previous section. We note that normalized weight decay allowed us to use a constant parameter setting across short and long runs performed within AdamWR and SGDWR (SGDW with warm restarts).
+
+# C AN EXAMPLE SETTING OF THE SCHEDULE MULTIPLIER
+
+An example schedule of the schedule multiplier $\eta _ { t }$ is given in SuppFigure 1 for $T _ { i = 0 } = 1 0 0$ and $T _ { m u l t } = 2$ . After the initial 100 epochs the learning rate will reach 0 because $\eta _ { t = 1 0 0 } = 0$ . Then, since $T _ { c u r } = T _ { i = 0 }$ , we restart by resetting $T _ { c u r } = 0$ , causing the multiplier $\eta _ { t }$ to be reset to 1 due to Eq. (15). This multiplier will then decrease again from 1 to 0, but now over the course of 200 epochs because $T _ { i = 1 } = T _ { i = 0 } T _ { m u l t } = 2 0 0$ . Solutions obtained right before the restarts, when $\eta _ { t } = 0$ (e.g., at epoch indexes 100, 300, 700 and 1500 as shown in SuppFigure 1) are recommended by the optimizer as the solutions, with more recent solutions prioritized.
+
+# D ADDITIONAL RESULTS
+
+We investigated whether the use of much longer runs (1800 epochs) of “standard Adam” (Adam with $\mathrm { L _ { 2 } }$ regularization and a fixed learning rate) makes the use of cosine annealing unnecessary.
+
+![](images/05aeac11b243ee1c9b6ee060aff58ac2592760fb64cd2d49c797565303ec0f23.jpg)  
+SuppFigure 1: An example schedule of the learning rate multiplier as a function of epoch index. The first run is scheduled to converge at epoch $T _ { i = 0 } ~ = ~ 1 0 0$ , then the budget for the next run is doubled as $T _ { i = 1 } = T _ { i = 0 } T _ { m u l t } = 2 0 0$ , etc.
+
+SuppFigure 2 shows the results of standard Adam for a 4 by 4 logarithmic grid of hyperparameter settings (the coarseness of the grid is due to the high computational expense of runs for 1800 epochs). Even after taking the low resolution of the grid into account, the results appear to be at best comparable to the ones obtained with AdamW with 18 times less epochs and a smaller network (see SuppFigure 3, top row, middle). These results are not very surprising given Figure 2 in the main paper (which demonstrates the effectiveness of AdamW) and SuppFigure 1 (which demonstrates the necessity to use some learning rate schedule such as cosine annealing).
+
+Our experimental results with Adam and SGD suggested that the total runtime in terms of the number of epochs affect the basin of optimal hyperparameters (see SuppFigure 3). More specifically, the greater the total number of epochs the smaller the values of the weight decay should be. SuppFigure 4 shows that our remedy for this problem, the normalized weight decay defined in Eq. (15), simplifies hyperparameter selection because the optimal values observed for short runs are similar to the ones for much longer runs. We used our initial experiments on CIFAR-10 to suggest the square root normalization we proposed in Eq. (15) and double-checked that this is not a coincidence on the ImageNet32x32 dataset (Chrabaszcz et al., 2017), a downsampled version of the original ImageNet dataset with 1.2 million $3 2 \times 3 2$ pixels images, where an epoch is 24 times longer than on CIFAR-10. This experiment also supported the square root scaling: the best values of the normalized weight decay observed on CIFAR-10 represented nearly optimal values for ImageNet32x32 (see SuppFigure 3). In contrast, had we used the same raw weight decay values $\lambda$ for ImageNet32x32 as for CIFAR10 and for the same number of epochs, without the proposed normalization, $\lambda$ would have been roughly 5 times too large for ImageNe $3 2 x 3 2$ , leading to much worse performance. The optimal normalized weight decay values were also very similar (e.g., $\lambda _ { n o r m } = 0 . 0 2 5$ and $\lambda _ { n o r m } = 0 . 0 5 )$ ) across SGDW and AdamW.
+
+SuppFigure 4 is the equivalent of Figure 3 in the main paper, but for ImageNet32x32 instead of for CIFAR-10. The qualitative results are identical: weight decay leads to better training loss (crossentropy) than $\mathrm { L _ { 2 } }$ regularization, and to an even greater improvement of test error.
+
+SuppFigure 5 and SuppFigure 6 are the equivalents of Figure 4 in the main paper but supplemented with training loss curves in its bottom row. The results show that Adam and its variants with decoupled weight decay converge faster (in terms of training loss) on CIFAR-10 than the corresponding SGD variants (the difference for ImageNet32x32 is small). As is discussed in the main paper, when the same values of training loss are considered, AdamW demonstrates better values of test error than Adam. Interestingly, SuppFigure 5 and SuppFigure 6 show that restart variants AdamWR and SGDWR also demonstrate better generalization than AdamW and SGDW, respectively.
+
+![](images/d61e04f283fa31f4651067bc40c835a7e0d1c6120984b5b1ce501d36ef00cee2.jpg)  
+SuppFigure 2: Performance of “standard Adam”: Adam with $\mathrm { L _ { 2 } }$ regularization and a fixed learning rate. We show the final test error of a $2 6 ~ 2 \mathrm { x } 9 6 \mathrm { d }$ ResNet on CIFAR-10 after 1800 epochs of the original Adam for different settings of learning rate and weight decay used for $\mathrm { L _ { 2 } }$ regularization.
+
+![](images/dd04a2ab90cfc312d3ac98c8dc68782db24031d7719e24db29f24240372c8b49.jpg)  
+SuppFigure 3: Effect of normalized weight decay. We show the final test Top-1 error on CIFAR10 (first two rows for AdamW without and with normalized weight decay) and Top-5 error on ImageNet32x32 (last two rows for AdamW and SGDW, both with normalized weight decay) of a $2 6 2 \mathrm { x } 6 4 \mathrm { d }$ ResNet after different numbers of epochs (see columns). While the optimal settings of the raw weight decay change significantly for different runtime budgets (see the first row), the values of the normalized weight decay remain very similar for different budgets (see the second row) and different datasets (here, CIFAR-10 and ImageNet32x32), and even across AdamW and SGDW.
+
+![](images/cae7758f0603d244c6a3533a4e7895f997ffe6ec31c9bfd389ed44477fe94759.jpg)  
+SuppFigure 4: Learning curves (top row) and generalization results (Top-5 errors in bottom row) obtained by a $2 6 2 \mathrm { x } 9 6 \mathrm { d }$ ResNet trained with Adam and AdamW on ImageNet32x32.
+
+![](images/5ab029b7e35779e3bea2ccd6ef38c9aa1439a43f3f4434a679a70961745062d0.jpg)  
+SuppFigure 5: Test error curves (top row) and training loss curves (bottom row) for CIFAR-10.
+
+![](images/1eca1bdf2cf4c17312faab960a100d5dd1708b424add1e9f49f170d4725df754.jpg)  
+SuppFigure 6: Test error curves (top row) and training loss curves (bottom row) for ImageNet32x32.

parse/train/Bkg6RiCqY7/Bkg6RiCqY7_content_list.json

@@ -0,0 +1,1675 @@
+[
+    {
+        "type": "text",
+        "text": "DECOUPLED WEIGHT DECAY REGULARIZATION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            753,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov & Frank Hutter ",
+        "bbox": [
+            184,
+            145,
+            408,
+            159
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "University of Freiburg   \nFreiburg, Germany,   \nilya.loshchilov@gmail.com, fh@cs.uni-freiburg.de ",
+        "bbox": [
+            184,
+            160,
+            655,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            237,
+            544,
+            252
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "$\\mathrm { L _ { 2 } }$ regularization and weight decay regularization are equivalent for standard stochastic gradient descent (when rescaled by the learning rate), but as we demonstrate this is not the case for adaptive gradient algorithms, such as Adam. While common implementations of these algorithms employ $\\mathrm { L _ { 2 } }$ regularization (often calling it “weight decay” in what may be misleading due to the inequivalence we expose), we propose a simple modification to recover the original formulation of weight decay regularization by decoupling the weight decay from the optimization steps taken w.r.t. the loss function. We provide empirical evidence that our proposed modification (i) decouples the optimal choice of weight decay factor from the setting of the learning rate for both standard SGD and Adam and (ii) substantially improves Adam’s generalization performance, allowing it to compete with SGD with momentum on image classification datasets (on which it was previously typically outperformed by the latter). Our proposed decoupled weight decay has already been adopted by many researchers, and the community has implemented it in TensorFlow and PyTorch; the complete source code for our experiments is available at https://github.com/loshchil/AdamW-and-SGDW ",
+        "bbox": [
+            233,
+            270,
+            764,
+            492
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            522,
+            336,
+            537
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Adaptive gradient methods, such as AdaGrad (Duchi et al., 2011), RMSProp (Tieleman & Hinton, 2012), Adam (Kingma & Ba, 2014) and most recently AMSGrad (Reddi et al., 2018) have become a default method of choice for training feed-forward and recurrent neural networks (Xu et al., 2015; Radford et al., 2015). Nevertheless, state-of-the-art results for popular image classification datasets, such as CIFAR-10 and CIFAR-100 Krizhevsky (2009), are still obtained by applying SGD with momentum (Gastaldi, 2017; Cubuk et al., 2018). Furthermore, Wilson et al. (2017) suggested that adaptive gradient methods do not generalize as well as SGD with momentum when tested on a diverse set of deep learning tasks, such as image classification, character-level language modeling and constituency parsing. Different hypotheses about the origins of this worse generalization have been investigated, such as the presence of sharp local minima (Keskar et al., 2016; Dinh et al., 2017) and inherent problems of adaptive gradient methods (Wilson et al., 2017). In this paper, we investigate whether it is better to use $\\mathrm { L _ { 2 } }$ regularization or weight decay regularization to train deep neural networks with SGD and Adam. We show that a major factor of the poor generalization of the most popular adaptive gradient method, Adam, is due to the fact that $\\mathrm { L _ { 2 } }$ regularization is not nearly as effective for it as for SGD. Specifically, our analysis of Adam leads to the following observations: ",
+        "bbox": [
+            174,
+            555,
+            825,
+            762
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { L } _ { 2 }$ regularization and weight decay are not identical. Contrary to a belief which seems popular among some practitioners, the two techniques are not equivalent. For SGD, they can be made equivalent by a reparameterization of the weight decay factor based on the learning rate; this is not the case for Adam. In particular, when combined with adaptive gradients, $\\mathrm { L _ { 2 } }$ regularization leads to weights with large parameter and/or gradient amplitudes being regularized less than they would be when using weight decay. ",
+        "bbox": [
+            183,
+            777,
+            823,
+            862
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { L } _ { 2 }$ regularization is not effective in Adam. One possible explanation why Adam and other adaptive gradient methods might be outperformed by SGD with momentum is that common deep learning libraries only implement $\\mathrm { L _ { 2 } }$ regularization, not the original weight decay. Therefore, on tasks/datasets where the use of $\\mathrm { L _ { 2 } }$ regularization is beneficial for SGD (e.g., on many popular image classification datasets), Adam leads to worse results than SGD with momentum (for which $\\mathrm { L _ { 2 } }$ regularization behaves as expected). ",
+        "bbox": [
+            183,
+            868,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            228,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Weight decay is equally effective in both SGD and Adam. For SGD, it is equivalent to $\\mathrm { L _ { 2 } }$ regularization, while for Adam it is not. ",
+        "bbox": [
+            181,
+            136,
+            821,
+            164
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Optimal weight decay depends on the total number of batch passes/weight updates. Our empirical analysis of SGD and Adam suggests that the larger the runtime/number of batch passes to be performed, the smaller the optimal weight decay. This effect tends to be neglected because hyperparameters are often tuned for a fixed number of training epochs. As a result, the values of the weight decay found to perform best for short runs do not generalize to much longer runs. ",
+        "bbox": [
+            183,
+            169,
+            825,
+            252
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main contribution of this paper is to improve regularization in Adam by decoupling the weight decay from the gradient-based update. In a comprehensive analysis, we show that Adam generalizes substantially better with decoupled weight decay than with $\\mathrm { L _ { 2 } }$ regularization, achieving $15 \\%$ relative improvement in test error (see Figures 2 and 3); this holds true for various image recognition datasets (CIFAR-10 and ImageNet32x32), training budgets (ranging from 100 to 1800 epochs), and learning rate schedules (fixed, drop-step, and cosine annealing; see Figure 1). We demonstrate that our decoupled weight decay renders the optimal settings of the learning rate and the weight decay factor much more independent, thereby easing hyperparameter optimization (see Figure 2). ",
+        "bbox": [
+            173,
+            265,
+            825,
+            377
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main motivation of this paper is to improve Adam to make it competitive w.r.t. SGD with momentum even for those problems where it did not use to be competitive. We hope that as a result, practitioners do not need to switch between Adam and SGD anymore, which in turn should reduce the common issue of selecting dataset/task-specific training algorithms and their hyperparameters. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            439
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 DECOUPLING THE WEIGHT DECAY FROM THE GRADIENT-BASED UPDATE",
+        "bbox": [
+            174,
+            459,
+            816,
+            476
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the weight decay described by Hanson & Pratt (1988), the weights $\\pmb \\theta$ decay exponentially as ",
+        "bbox": [
+            173,
+            489,
+            795,
+            506
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f81ce8600080bc8924728648634ee9f4bcff28e5f5a49122865b38acc2338ec0.jpg",
+        "text": "$$\n\\pmb { \\theta } _ { t + 1 } = ( 1 - \\lambda ) \\pmb { \\theta } _ { t } - \\alpha \\nabla f _ { t } ( \\pmb { \\theta } _ { t } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            511,
+            588,
+            529
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda$ defines the rate of the weight decay per step and $\\nabla f _ { t } ( \\pmb { \\theta } _ { t } )$ is the $t$ -th batch gradient to be multiplied by a learning rate $\\alpha$ . For standard SGD, it is equivalent to standard $\\mathrm { L _ { 2 } }$ regularization: ",
+        "bbox": [
+            173,
+            535,
+            825,
+            563
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1 (Weight decay ${ \\bf \\tau } = { \\bf L } _ { 2 }$ reg for standard SGD). Standard SGD with base learning rate $\\alpha$ executes the same steps on batch loss functions $f _ { t } ( \\pmb \\theta )$ with weight decay $\\lambda$ (defined in Equation $I$ ) as it executes without weight decay on $\\begin{array} { r } { f _ { t } ^ { r e g } ( { \\pmb { \\theta } } ) = f _ { t } ( { \\pmb { \\theta } } ) + \\frac { \\lambda ^ { \\prime } } { 2 } \\left\\| { \\pmb { \\theta } } \\right\\| _ { 2 } ^ { 2 } } \\end{array}$ , with $\\begin{array} { r } { \\lambda ^ { \\prime } = \\frac { \\lambda } { \\alpha } } \\end{array}$ . ",
+        "bbox": [
+            174,
+            566,
+            825,
+            614
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The proofs of this well-known fact, as well as our other propositions, are given in the Appendix A. ",
+        "bbox": [
+            173,
+            623,
+            818,
+            638
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Due to this equivalence, $\\mathrm { L _ { 2 } }$ regularization is very frequently referred to as weight decay, including in popular deep learning libraries. However, as we will demonstrate later in this section, this equivalence does not hold for adaptive gradient methods. One fact that is often overlooked already for the simple case of SGD is that in order for the equivalence to hold, the $\\mathrm { L _ { 2 } }$ regularizer $\\lambda ^ { \\prime }$ has to be set to $\\frac { \\lambda } { \\underset { \\mathbf { x } } { \\alpha } }$ , i.e., if there ie learning rate n overall best weight decay value . In order to decouple the effects $\\lambda$ , the best value of  these two hyperp $\\lambda ^ { \\prime }$ is tightly coupled withmeters, we advocate to $\\alpha$ decouple the weight decay step as proposed by Hanson & Pratt (1988) (Equation 1). ",
+        "bbox": [
+            174,
+            645,
+            825,
+            743
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Looking first at the case of SGD, we propose to decay the weights simultaneously with the update of $\\theta _ { t }$ based on gradient information in Line 9 of Algorithm 1. This yields our proposed variant of SGD with momentum using decoupled weight decay (SGDW). This simple modification explicitly decouples $\\lambda$ and $\\alpha$ (although some problem-dependent implicit coupling may of course remain as for any two hyperparameters). In order to account for a possible scheduling of both $\\alpha$ and $\\lambda$ , we introduce a scaling factor $\\eta _ { t }$ delivered by a user-defined procedure SetScheduleMultiplier $( t )$ . ",
+        "bbox": [
+            173,
+            750,
+            825,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Now, let’s turn to adaptive gradient algorithms like the popular optimizer Adam Kingma & Ba (2014), which scale gradients by their historic magnitudes. Intuitively, when Adam is run on a loss function $f$ plus $\\mathrm { L _ { 2 } }$ regularization, weights that tend to have large gradients in $f$ do not get regularized as much as they would with decoupled weight decay, since the gradient of the regularizer gets scaled along with the gradient of $f$ . This leads to an inequivalence of $\\mathrm { L _ { 2 } }$ and decoupled weight decay regularization for adaptive gradient algorithms: ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/d28caad00fcf5caa5d4473cafd1a45b04c0393d1844616f9e5acbea388ec756e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm 1 SGD with L2 regularization</td><td></td><td>SGD with decoupled weight decay (SGDW) both</td></tr><tr><td>with momentum</td><td colspan=\"2\"></td></tr></table>",
+        "bbox": [
+            173,
+            103,
+            823,
+            136
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1: given initial learning rate $\\alpha \\in \\mathbb { R }$ , momentum factor $\\beta _ { 1 } \\in \\mathbb { R }$ , weight decay/L2 regularization factor $\\overline { { \\lambda \\in \\mathbb { R } } }$   \n2: initialize time step $t  0$ , parameter vector $\\pmb { \\theta } _ { t = 0 } ~ \\in ~ \\mathbb { R } ^ { n }$ , first moment vector $\\pmb { m } _ { t = 0 } \\gets \\pmb { \\theta }$ , schedule   \nmultiplier $\\eta _ { t = 0 } \\in \\mathbb { R }$   \n3: repeat   \n4: $t \\gets t + 1$   \n5: $\\nabla f _ { t } \\big ( \\pmb { \\theta } _ { t - 1 } \\big ) \\gets \\mathrm { S e l e c t B a t c h } \\big ( \\pmb { \\theta } _ { t - 1 } \\big )$ . select batch and return the corresponding gradient   \n6: $\\pmb { g } _ { t } \\gets \\nabla f _ { t } ( \\pmb { \\theta } _ { t - 1 } ) \\ + \\lambda \\pmb { \\theta } _ { t - 1 }$   \n7: ηt ← SetScheduleMultiplier(t) . can be fixed, decay, be used for warm restarts   \n8: ${ \\pmb { m } } _ { t } \\gets \\beta _ { 1 } { \\pmb { m } } _ { t - 1 } + \\eta _ { t } \\alpha { \\pmb { g } } _ { t }$   \n9: $\\pmb { \\theta } _ { t } \\gets \\pmb { \\theta } _ { t - 1 } - \\pmb { m } _ { t } - \\eta _ { t } \\lambda \\pmb { \\theta } _ { t - 1 }$   \n10: until stopping criterion is met   \n11: return optimized parameters ${ \\pmb \\theta } _ { t }$   \n1: given $\\alpha = 0 . 0 0 1 , \\beta _ { 1 } = 0 . 9 , \\beta _ { 2 } = 0 . 9 9 9 , \\epsilon = 1 0 ^ { - 8 } , \\lambda \\in \\mathbb { R }$   \n2: initialize time step $t \\gets 0$ , parameter vector $\\pmb { \\theta } _ { t = 0 } \\in \\mathbb { R } ^ { n }$ , first moment vector $\\pmb { m } _ { t = 0 }  \\pmb { \\theta }$ , second moment   \nvector $\\pmb { \\nu } _ { t = 0 }  \\pmb { \\theta }$ , schedule multiplier $\\eta _ { t = 0 } \\in \\mathbb { R }$   \n3: repeat   \n4: $t \\gets t + 1$   \n5: $\\nabla f _ { t } (  { \\mathbf { \\dot { \\theta } } } _ { t - 1 } ^ { \\phantom { \\dagger } } ) \\gets \\mathrm { S e l e c t B a t c h } (  { \\mathbf { \\theta } } _ { t - 1 } )$ . select batch and return the corresponding gradient   \n6: $\\pmb { \\mathscr { g } } _ { t } \\gets \\nabla f _ { t } ( \\pmb { \\theta } _ { t - 1 } ) \\ + \\lambda \\pmb { \\theta } _ { t - 1 }$   \n7: $\\pmb { m } _ { t } \\gets \\beta _ { 1 } \\pmb { m } _ { t - 1 } + ( 1 - \\beta _ { 1 } ) \\pmb { g } _ { t }$ . here and below all operations are element-wise   \n8: $\\pmb { \\nu } _ { t } \\gets \\beta _ { 2 } \\pmb { \\nu } _ { t - 1 } + ( 1 - \\beta _ { 2 } ) \\pmb { g } _ { t } ^ { 2 }$   \n9: $\\hat { { \\pmb { m } } } _ { t } \\gets { \\pmb { m } } _ { t } / ( 1 - \\beta _ { 1 } ^ { t } )$ . $\\beta _ { 1 }$ is taken to the power of $t$   \n10: ˆvt ← vt/(1 − βt2) . $\\beta _ { 2 }$ is taken to the power of $t$   \n11: $\\eta _ { t } \\gets$ SetScheduleMultiplier(t) . can be fixed, decay, or also be used for warm restarts   \n12: θt ← θt−1 − ηt \u0010αmˆ t/( ˆvt + \u000f) +λθt−1   \n13: until stopping criterion is met ",
+        "bbox": [
+            174,
+            138,
+            825,
+            314
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/427aa4b7248d59bec9c9c1190f8d57ada93091c883fb27d91441fcc12e42681d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm 2 Adam with L2 regularization</td><td>and</td></tr></table>",
+        "bbox": [
+            173,
+            345,
+            807,
+            366
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            369,
+            825,
+            565
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "14: return optimized parameters ${ \\pmb \\theta } _ { t }$ ",
+        "bbox": [
+            176,
+            564,
+            393,
+            577
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Proposition 2 (Weight decay $\\neq \\mathrm { L } _ { 2 }$ reg for adaptive gradients). Let $O$ denote an optimizer that has iterates $\\pmb { \\theta } _ { t + 1 }  \\pmb { \\theta } _ { t } - \\alpha \\mathbf { M } _ { t } \\nabla f _ { t } ( \\pmb { \\theta } _ { t } )$ when run on batch loss function $f _ { t } ( \\pmb \\theta )$ without weight decay, and $\\pmb { \\theta } _ { t + 1 } \\gets ( 1 - \\lambda ) \\pmb { \\theta } _ { t } - \\alpha \\mathbf { M } _ { t } \\nabla f _ { t } ( \\pmb { \\theta } _ { t } )$ when run on $f _ { t } ( \\pmb \\theta )$ with weight decay, respectively, with $\\mathbf { M } _ { t } \\neq k \\mathbf { I }$ (where $k \\in \\mathbb { R } ,$ ). Then, for $O$ there exists no $L _ { 2 }$ coefficient $\\lambda ^ { \\prime }$ such that running $O$ on batch loss $\\begin{array} { r } { f _ { t } ^ { r e g } ( { \\pmb \\theta } ) = f _ { t } ( { \\pmb \\theta } ) + \\frac { \\lambda ^ { \\prime } } { 2 } \\left. { \\pmb \\theta } \\right. _ { 2 } ^ { 2 } } \\end{array}$ without weight decay is equivalent to running $O$ on $f _ { t } ( \\pmb \\theta )$ with decay $\\lambda \\in \\mathbb { R } ^ { + }$ . ",
+        "bbox": [
+            173,
+            617,
+            825,
+            705
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We decouple weight decay and loss-based gradient updates in Adam as shown in line 12 of Algorithm 2; this gives rise to our variant of Adam with decoupled weight decay (AdamW). ",
+        "bbox": [
+            173,
+            722,
+            823,
+            750
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Having shown that $\\mathrm { L _ { 2 } }$ regularization and weight decay regularization differ for adaptive gradient algorithms raises the question of how they differ and how to interpret their effects. Their equivalence for standard SGD remains very helpful for intuition: both mechanisms push weights closer to zero, at the same rate. However, for adaptive gradient algorithms they differ: with $\\mathrm { L _ { 2 } }$ regularization, the sums of the gradient of the loss function and the gradient of the regularizer (i.e., the $\\mathrm { L _ { 2 } }$ norm of the weights) are adapted, whereas with weight decay, only the gradients of the loss function are adapted (with the weight decay step separated from the adaptive gradient mechanism). With $\\mathrm { L _ { 2 } }$ regularization both types of gradients are normalized by their typical (summed) magnitudes, and therefore weights $x$ with large typical gradient magnitude $s$ are regularized by a smaller relative amount than other weights. In contrast, weight decay regularizes all weights with the same rate $\\lambda$ , effectively regularizing weights $x$ with large $s$ more than standard $\\mathrm { L _ { 2 } }$ regularization does. We demonstrate this formally for a simple special case of adaptive gradient algorithm with a fixed preconditioner: ",
+        "bbox": [
+            174,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Proposition 3 (Weight decay $=$ scale-adjusted $L _ { 2 }$ reg for adaptive gradient algorithm with fixed preconditioner). Let $O$ denote an algorithm with the same characteristics as in Proposition 2, and using a fixed preconditioner matrix ${ \\bf \\bar { \\cal M } } _ { t } = d i a g ( s ) ^ { - 1 }$ (with $s _ { i } > 0$ for all $i _ { , }$ ). Then, $O$ with base learning rate $\\alpha$ executes the same steps on batch loss functions $f _ { t } ( \\pmb \\theta )$ with weight decay $\\lambda$ as it executes without weight decay on the scale-adjusted regularized batch loss ",
+        "bbox": [
+            173,
+            102,
+            825,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d2f73cbd4b3badd7ea44a4678ea341de35400758883285a44a5d1c0161c90886.jpg",
+        "text": "$$\nf _ { t } ^ { s r e g } ( \\pmb { \\theta } ) = f _ { t } ( \\pmb { \\theta } ) + \\frac { \\lambda ^ { \\prime } } { 2 \\alpha } \\left\\| \\pmb { \\theta } \\odot \\sqrt { \\pmb { s } } \\right\\| _ { 2 } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            176,
+            619,
+            208
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\odot$ and $\\sqrt { \\cdot }$ denote element-wise multiplication and square root, respectively, and $\\begin{array} { r } { \\lambda ^ { \\prime } = \\frac { \\lambda } { \\alpha } } \\end{array}$ ",
+        "bbox": [
+            171,
+            217,
+            794,
+            233
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 JUSTIFICATION OF DECOUPLED WEIGHT DECAY VIA A VIEW OF ADAPTIVE GRADIENT METHODS AS BAYESIAN FILTERING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            256,
+            740,
+            291
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now discuss a justification of decoupled weight decay in the framework of Bayesian filtering for a unified theory of adaptive gradient algorithms due to Aitchison (2018). After we posted a preliminary version of our current paper on arXiv, Aitchison noted that his theory “gives us a theoretical framework in which we can understand the superiority of this weight decay over $L _ { 2 }$ regularization, because it is weight decay, rather than $L _ { 2 }$ regularization that emerges through the straightforward application of Bayesian filtering.”(Aitchison, 2018). While full credit for this theory goes to Aitchison, we summarize it here to shed some light on why weight decay may be favored over $L _ { 2 }$ regularization. ",
+        "bbox": [
+            173,
+            308,
+            825,
+            420
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Aitchison (2018) views stochastic optimization of $n$ parameters $x _ { 1 } , \\ldots , x _ { n }$ as a Bayesian filtering problem with the goal of inferring a distribution over the optimal values of each of the parameters $x _ { i }$ given the current values of the other parameters $\\pmb \\theta _ { - i } ( t )$ at time step $t$ . When the other parameters do not change this is an optimization problem, but when they do change it becomes one of “tracking” the optimizer using Bayesian filtering as follows. One is given a probability distribution $\\bar { P ( \\pmb \\theta _ { t } ) } \\ |$ $y _ { 1 : t } )$ of the optimizer at time step $t$ that takes into account the data $\\scriptstyle { \\boldsymbol { y } } _ { 1 : t }$ from the first $t$ mini batches, a state transition prior $P ( \\pmb \\theta _ { t + 1 } \\mid \\pmb \\theta _ { t } )$ reflecting a (small) data-independent change in this distribution from one step to the next, and a likelihood $\\mathbf { \\bar { \\ u } } _ { P ( \\pmb { y } _ { t + 1 } \\mid \\mathbf { \\theta } _ { t + 1 } ) }$ derived from the mini batch at step $t + 1$ . The posterior distribution $P ( \\pmb { \\theta } _ { t + 1 } \\mid \\mathbf { y } _ { 1 : t + 1 } )$ of the optimizer at time step $t + 1$ can then be computed (as usual in Bayesian filtering) by marginalizing over $\\theta _ { t }$ to obtain the onestep ahead predictions $P ( \\pmb { \\theta } _ { t + 1 } \\mid \\pmb { y } _ { 1 : t } )$ and then applying Bayes’ rule to incorporate the likelihood $\\textstyle P ( \\mathbf { \\bar { y } } _ { t + 1 } \\mid \\theta _ { t + 1 } )$ . Aitchison (2018) assumes a Gaussian state transition distribution $P ( \\pmb \\theta _ { t + 1 } \\mid \\pmb \\theta _ { t } )$ and an approximate conjugate likelihood $\\textstyle P ( \\pmb { y } _ { t + 1 } \\mid \\pmb { \\theta } _ { t + 1 } )$ , leading to the following closed-form update of the filtering distribution’s mean: ",
+        "bbox": [
+            173,
+            426,
+            825,
+            621
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6e63676b3bb3b5319b7de8b42bd389c6c33d70aaafbc1affe0bbc3fda6910821.jpg",
+        "text": "$$\n\\begin{array} { r } { \\pmb { \\mu } _ { p o s t } = \\pmb { \\mu } _ { p r i o r } + \\pmb { \\Sigma } _ { p o s t } \\times \\pmb { g } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            632,
+            598,
+            650
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\textbf {  { g } }$ is the gradient of the log likelihood of the mini batch at time $t$ . This result implies a preconditioner of the gradients that is given by the posterior uncertainty $\\Sigma _ { p o s t }$ of the filtering distribution: updates are larger for parameters we are more uncertain about and smaller for parameters we are more certain about. Aitchison (2018) goes on to show that popular adaptive gradient methods, such as Adam and RMSprop, as well as Kronecker-factorized methods are special cases of this framework. ",
+        "bbox": [
+            174,
+            660,
+            823,
+            744
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Decoupled weight decay very naturally fits into this unified framework can express weight decay as part of the state-transition distribution: Aitchison (2018) assumes a slow change of the optimizer according to the following Gaussian: ",
+        "bbox": [
+            174,
+            751,
+            825,
+            792
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c33ccc7525a2c3a479e48f9ee6eb2aab1cd47603d352fea8c880562351ac2f7b.jpg",
+        "text": "$$\nP ( \\pmb \\theta _ { t + 1 } \\mid \\pmb \\theta _ { t } ) = N ( ( \\pmb I - \\pmb A ) \\pmb \\theta _ { t } , \\pmb Q ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            804,
+            617,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $Q$ is the covariance of Gaussian perturbations of the weights, and $\\pmb { A }$ is a regularizer to avoid values growing unboundedly over time. When instantiated as $A = \\lambda \\times I$ , this regularizer $\\pmb { A }$ plays exactly the role of decoupled weight decay as described in Equation 1, since this leads to multiplying the current mean estimate $\\theta _ { t }$ by $( 1 - \\lambda )$ at each step. Notably, this regularization is also directly applied to the prior and does not depend on the uncertainty in each of the parameters (which would be required for $L _ { 2 }$ regularization). ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/cdc01f838cc870b7893f2bd8b1b4fdadd1d0ed078db65ddff2d8aef49b319780.jpg",
+        "image_caption": [
+            "Figure 1: Adam performs better with decoupled weight decay (bottom row, AdamW) than with $L _ { 2 }$ regularization (top row, Adam). We show the final test error of a $2 6 ~ 2 \\mathrm { x } 6 4 \\mathrm { d }$ ResNet on CIFAR-10 after 100 epochs of training with fixed learning rate (left column), step-drop learning rate (with drops at epoch indexes 30, 60 and 80, middle column) and cosine annealing (right column). AdamW leads to a more separable hyperparameter search space, especially when a learning rate schedule, such as step-drop and cosine annealing is applied. Cosine annealing yields clearly superior results. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            98,
+            774,
+            382
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL VALIDATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            515,
+            446,
+            530
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now evaluate the performance of decoupled weight decay under various training budgets and learning rate schedules. Our experimental setup follows that of Gastaldi (2017), who proposed, in addition to $\\mathrm { L _ { 2 } }$ regularization, to apply the new Shake-Shake regularization to a 3-branch residual DNN that allowed to achieve new state-of-the-art results of $2 . 8 6 \\%$ on the CIFAR-10 dataset (Krizhevsky, 2009). We always used a batch size of 128. The regular data augmentation procedure used for the CIFAR datasets was applied. We used the same model/source code based on fb.resnet.torch 1. The base networks are a $2 6 ~ 2 \\mathrm { x } 6 4 \\mathrm { d }$ ResNet (i.e. the network has a depth of 26, 2 residual branches and the first residual block has a width of 64) and a $2 6 2 \\mathrm { x } 9 6 \\mathrm { d }$ ResNet with $1 1 . 6 \\mathbf { M }$ and $2 5 . 6 \\mathbf { M }$ parameters, respectively. For a detailed description of the network and the Shake-Shake method, we refer the interested reader to Gastaldi (2017). We also perform experiments on the ImageNet32x32 dataset (Chrabaszcz et al., 2017), a downsampled version of the original ImageNet dataset with 1.2 million $3 2 \\times 3 2$ pixels images. ",
+        "bbox": [
+            174,
+            549,
+            825,
+            715
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 EVALUATING DECOUPLED WEIGHT DECAY WITH DIFFERENT LEARNING RATE SCHEDULES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            737,
+            761,
+            765
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our first experiment, we compare Adam with $L _ { 2 }$ regularization to Adam with decoupled weight decay (AdamW), using three different learning rate schedules: a fixed learning rate, a drop-step schedule, and a cosine annealing schedule (Loshchilov & Hutter, 2016). For each learning rate schedule and weight decay variant, we trained a 2x64d ResNet for 100 epochs, using different settings of the initial learning rate $\\alpha$ and the weight decay factor $\\lambda$ . Figure 1 shows that decoupled weight decay outperforms $L _ { 2 }$ regularization for all learning rate schedules, with larger differences for better learning rate schedules. We also note that decoupled weight decay leads to a more separable hyperparameter search space, especially when a learning rate schedule, such as step-drop and cosine annealing is applied. The figure also shows that cosine annealing clearly outperforms the other learning rate schedules; we thus used cosine annealing for the remainder of the experiments. ",
+        "bbox": [
+            173,
+            779,
+            825,
+            891
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/912ae7b475cea2253f76582036e0793936fecf71a117beab28917bbc8e28d712.jpg",
+        "image_caption": [
+            "Figure 2: The Top-1 test error of a 26 2x64d ResNet on CIFAR-10 measured after 100 epochs. The proposed SGDW and AdamW (right column) have a more separable hyperparameter space. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            98,
+            754,
+            410
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/ebfc9d3556d4d95c8aaba3765fe521f34e36b21c331fc769c98b81b49d5fe39f.jpg",
+        "image_caption": [
+            "Figure 3: Learning curves (top row) and generalization results (bottom row) obtained by a 26 $2 \\mathrm { x } 9 6 \\mathrm { d }$ ResNet trained with Adam and AdamW on CIFAR-10. See text for details. SuppFigure 4 in the Appendix shows the same qualitative results for ImageNet $3 2 \\mathbf { x } 3 2$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            487,
+            754,
+            794
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 DECOUPLING THE WEIGHT DECAY AND INITIAL LEARNING RATE PARAMETERS",
+        "bbox": [
+            173,
+            103,
+            771,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to verify our hypothesis about the coupling of $\\alpha$ and $\\lambda$ , in Figure 2 we compare the performance of $\\mathrm { L _ { 2 } }$ regularization vs. decoupled weight decay in SGD (SGD vs. SGDW, top row) and in Adam (Adam vs. AdamW, bottom row). In SGD (Figure 2, top left), $\\mathrm { L _ { 2 } }$ regularization is not decoupled from the learning rate (the common way as described in Algorithm 1), and the figure clearly shows that the basin of best hyperparameter settings (depicted by color and top-10 hyperparameter settings by black circles) is not aligned with the $\\mathbf { X }$ -axis or y-axis but lies on the diagonal. This suggests that the two hyperparameters are interdependent and need to be changed simultaneously, while only changing one of them might substantially worsen results. Consider, e.g., the setting at the top left black circle $( \\alpha = 1 / 2$ , $\\lambda \\overset { - } { = } 1 / 8 * 0 . 0 0 1 )$ ; only changing either $\\alpha$ or $\\lambda$ by itself would worsen results, while changing both of them could still yield clear improvements. We note that this coupling of initial learning rate and $\\mathrm { L _ { 2 } }$ regularization factor might have contributed to SGD’s reputation of being very sensitive to its hyperparameter settings. ",
+        "bbox": [
+            174,
+            140,
+            825,
+            306
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In contrast, the results for SGD with decoupled weight decay (SGDW) in Figure 2 (top right) show that weight decay and initial learning rate are decoupled. The proposed approach renders the two hyperparameters more separable: even if the learning rate is not well tuned yet (e.g., consider the value of 1/1024 in Figure 2, top right), leaving it fixed and only optimizing the weight decay factor would yield a good value (of $1 / 4 ^ { * } 0 . 0 0 1$ ). This is not the case for SGD with $\\mathrm { L _ { 2 } }$ regularization (see Figure 2, top left). ",
+        "bbox": [
+            174,
+            313,
+            825,
+            397
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results for Adam with $\\mathrm { L _ { 2 } }$ regularization are given in Figure 2 (bottom left). Adam’s best hyperparameter settings performed clearly worse than SGD’s best ones (compare Figure 2, top left). While both methods used $\\mathrm { L _ { 2 } }$ regularization, Adam did not benefit from it at all: its best results obtained for non-zero $\\mathrm { L _ { 2 } }$ regularization factors were comparable to the best ones obtained without the $\\mathrm { L _ { 2 } }$ regularization, i.e., when $\\lambda = 0$ . Similarly to the original SGD, the shape of the hyperparameter landscape suggests that the two hyperparameters are coupled. ",
+        "bbox": [
+            174,
+            404,
+            823,
+            488
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In contrast, the results for our new variant of Adam with decoupled weight decay (AdamW) in Figure 2 (bottom right) show that AdamW largely decouples weight decay and learning rate. The results for the best hyperparameter settings were substantially better than the best ones of Adam with $\\mathrm { L _ { 2 } }$ regularization and rivaled those of SGD and SGDW. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            550
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In summary, the results in Figure 2 support our hypothesis that the weight decay and learning rate hyperparameters can be decoupled, and that this in turn simplifies the problem of hyperparameter tuning in SGD and improves Adam’s performance to be competitive w.r.t. SGD with momentum. ",
+        "bbox": [
+            176,
+            558,
+            825,
+            599
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 BETTER GENERALIZATION OF ADAMW ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            643,
+            486,
+            657
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "While the previous experiment suggested that the basin of optimal hyperparameters of AdamW is broader and deeper than the one of Adam, we next investigated the results for much longer runs of 1800 epochs to compare the generalization capabilities of AdamW and Adam. ",
+        "bbox": [
+            176,
+            680,
+            823,
+            722
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We fixed the initial learning rate to 0.001 which represents both the default learning rate for Adam and the one which showed reasonably good results in our experiments. Figure 3 shows the results for 12 settings of the $\\mathrm { L _ { 2 } }$ regularization of Adam and 7 settings of the normalized weight decay of AdamW (the normalized weight decay represents a rescaling formally defined in the Appendix B.1, it amounts to a multiplicative factor which depends on the number of bath passes). Interestingly, while the dynamics of the learning curves of Adam and AdamW often coincided for the first half of the training run, AdamW often led to lower training loss and test errors (see Figure 3 top left and top right, respectively). Importantly, the use of weight decay in Adam did not yield as good results as in AdamW (see also Figure 3, bottom left). Next, we investigated whether AdamW’s better results were only due to better convergence or due to better generalization. The results in Figure 3 (bottom right) for the best settings of Adam and AdamW suggest that AdamW did not only yield better training loss but also yielded better generalization performance for similar training loss values. The results on ImageNet32x32 (see SuppFigure 4 in the Appendix) lead to the same conclusion of substantially improved generalization performance. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/601a579961d1f5b8ba84aa32ca7fd5710ad12c354741ccbf24164731e477145b.jpg",
+        "image_caption": [
+            "Figure 4: Top-1 test error on CIFAR-10 (left) and Top-5 test error on ImageNet32x32 (right). For a better resolution and with training loss curves, see SuppFigure 5 and SuppFigure 6 in the supplementary material. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            101,
+            790,
+            268
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 ADAMWR WITH WARM RESTARTS FOR BETTER ANYTIME PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            343,
+            728,
+            358
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to improve anytime performance of SGDW and AdamW we extended them with warm restarts of (Loshchilov & Hutter, 2016) to obtain SGDWR and AdamWR, respectively (see section B.2 in the Appendix). As Figure 4 shows, AdamWR greatly sped up AdamW on CIFAR-10 and ImageNet32x32, up to a factor of 10 (see the results at the first restart). For the default learning rate of 0.001, AdamW achieved $1 5 \\%$ relative improvement in test errors compared to Adam both on CIFAR-10 (also see Figure 3) and ImageNet $3 2 x 3 2$ (also see SuppFigure 5). AdamWR achieved the same improved results but with a much better anytime performance. These improvements closed most of the gap between Adam and SGDWR on CIFAR-10 and yielded comparable performance on ImageNet32x32. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            496
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.5 USE OF ADAMW ON OTHER DATASETS AND ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            518,
+            637,
+            531
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Several other research groups have already successfully applied AdamW in citable works. For example, Wang et al. (2018) used AdamW to train a novel architecture for face detection on the standard WIDER FACE dataset (Yang et al., 2016), obtaining almost 10x faster predictions than the previous state of the art algorithms while achieving comparable performance. Volker et al. (2018) employed ¨ AdamW with cosine annealing to train convolutional neural networks to classify and characterize error-related brain signals measured from intracranial electroencephalography (EEG) recordings. While their paper does not provide a comparison to Adam, they kindly provided us with a direct comparison of the two on their best-performing problem-specific network architecture Deep4Net and a variant of ResNet. AdamW with the same hyperparameter setting as Adam yielded higher test set accuracy on Deep4Net $7 3 . 6 8 \\%$ versus $7 1 . 3 7 \\%$ ) and statistically significantly higher test set accuracy on ResNet $( 7 2 . 0 4 \\%$ versus $6 1 . 3 4 \\%$ . Radford et al. (2018) employed AdamW to train Transformer (Vaswani et al., 2017) architectures to obtain new state-of-the-art results on a wide range of benchmarks for natural language understanding. Zhang et al. (2018) compared $\\mathrm { L _ { 2 } }$ regularization vs. weight decay for SGD, Adam and the Kronecker-Factored Approximate Curvature (K-FAC) optimizer (Martens & Grosse, 2015) on the CIFAR datasets with ResNet and VGG architectures, reporting that decoupled weight decay consistently outperformed $\\mathrm { L _ { 2 } }$ regularization in cases where they differ. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            781
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            806,
+            495,
+            821
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Following suggestions that adaptive gradient methods such as Adam might lead to worse generalization than SGD with momentum (Wilson et al., 2017), we identified and exposed the inequivalence of $\\mathrm { L _ { 2 } }$ regularization and weight decay for Adam. We empirically showed that our version of Adam with decoupled weight decay yields substantially better generalization performance than the common implementation of Adam with $\\mathrm { L _ { 2 } }$ regularization. We also proposed to use warm restarts for Adam to improve its anytime performance. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our results obtained on image classification datasets must be verified on a wider range of tasks, especially ones where the use of regularization is expected to be important. It would be interesting to integrate our findings on weight decay into other methods which attempt to improve Adam, e.g, normalized direction-preserving Adam (Zhang et al., 2017). While we focused our experimental analysis on Adam, we believe that similar results also hold for other adaptive gradient methods, such as AdaGrad (Duchi et al., 2011) and AMSGrad (Reddi et al., 2018). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            209,
+            387,
+            226
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This work was supported by the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme under grant no. 716721, by the German Research Foundation (DFG), under the BrainLinksBrainTools Cluster of Excellence (grant number EXC 1086) and through grant no. INST 37/935-1 FUGG, and by the German state of BadenWurttemberg through bwHPC. We thank Patryk Chrabaszcz for helping running experiments with ¨ ImageNet32x32. We thank Matthias Feurer and Robin Schirrmeister for providing valuable feedback on this paper in several iterations. We thank Martin Volker, Robin Schirrmeister, and Tonio ¨ Ball for providing us with a comparison of AdamW and Adam on their EEG data. ",
+        "bbox": [
+            174,
+            241,
+            825,
+            353
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, we thank the following members of the deep learning community for implementing decoupled weight decay in various deep learning libraries: ",
+        "bbox": [
+            173,
+            359,
+            821,
+            388
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "• Jingwei Zhang, Lei Tai, Robin Schirrmeister, and Kashif Rasul for their implementations in PyTorch (see https://github.com/pytorch/pytorch/pull/4429)   \n• Phil Jund for his implementation in TensorFlow described at https://www.tensorflow.org/api_docs/python/tf/contrib/opt/ DecoupledWeightDecayExtension Sylvain Gugger, Anand Saha, Jeremy Howard and other members of fast.ai for their implementation available at https://github.com/sgugger/Adam-experiments Guillaume Lambard for his implementation in Keras available at https://github. com/GLambard/AdamW_Keras   \n• Yagami Lin for his implementation in Caffe available at https://github.com/ Yagami123/Caffe-AdamW-AdamWR ",
+        "bbox": [
+            215,
+            400,
+            825,
+            565
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            588,
+            287,
+            604
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Laurence Aitchison. A unified theory of adaptive stochastic gradient descent as Bayesian filtering. arXiv:1507.02030, 2018. ",
+        "bbox": [
+            173,
+            613,
+            821,
+            642
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Patryk Chrabaszcz, Ilya Loshchilov, and Frank Hutter. A downsampled variant of ImageNet as an alternative to the CIFAR datasets. arXiv:1707.08819, 2017. ",
+        "bbox": [
+            169,
+            652,
+            823,
+            683
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ekin D Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V Le. Autoaugment: Learning augmentation policies from data. arXiv preprint arXiv:1805.09501, 2018. ",
+        "bbox": [
+            171,
+            693,
+            823,
+            722
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, Razvan Pascanu, Samy Bengio, and Yoshua Bengio. Sharp minima can generalize for deep nets. arXiv:1703.04933, 2017. ",
+        "bbox": [
+            173,
+            733,
+            823,
+            762
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. The Journal of Machine Learning Research, 12:2121–2159, 2011. ",
+        "bbox": [
+            173,
+            773,
+            823,
+            804
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xavier Gastaldi. Shake-Shake regularization. arXiv preprint arXiv:1705.07485, 2017. ",
+        "bbox": [
+            174,
+            814,
+            740,
+            830
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Stephen Jose Hanson and Lorien Y Pratt. Comparing biases for minimal network construction with ´ back-propagation. In Proceedings of the 1st International Conference on Neural Information Processing Systems, pp. 177–185, 1988. ",
+        "bbox": [
+            176,
+            840,
+            825,
+            883
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Yixuan Li, Geoff Pleiss, Zhuang Liu, John E Hopcroft, and Kilian Q Weinberger. Snapshot ensembles: Train 1, get m for free. arXiv:1704.00109, 2017. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv:1609.04836, 2016. ",
+        "bbox": [
+            174,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            173,
+            193,
+            692,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hao Li, Zheng Xu, Gavin Taylor, and Tom Goldstein. Visualizing the loss landscape of neural nets. arXiv preprint arXiv:1712.09913, 2017. ",
+        "bbox": [
+            169,
+            217,
+            821,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. SGDR: stochastic gradient descent with warm restarts. arXiv:1608.03983, 2016. ",
+        "bbox": [
+            169,
+            253,
+            823,
+            284
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James Martens and Roger Grosse. Optimizing neural networks with kronecker-factored approximate curvature. In International conference on machine learning, pp. 2408–2417, 2015. ",
+        "bbox": [
+            169,
+            291,
+            823,
+            321
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv:1511.06434, 2015. ",
+        "bbox": [
+            173,
+            329,
+            823,
+            359
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training. URL https://s3-us-west-2. amazonaws. com/openaiassets/research-covers/language-unsupervised/language understanding paper. pdf, 2018. ",
+        "bbox": [
+            174,
+            367,
+            821,
+            411
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sashank J. Reddi, Satyen Kale, and Sanjiv Kumar. On the convergence of adam and beyond. Inter national Conference on Learning Representations, 2018. ",
+        "bbox": [
+            174,
+            419,
+            818,
+            448
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Leslie N Smith. Cyclical learning rates for training neural networks. arXiv:1506.01186v3, 2016. ",
+        "bbox": [
+            171,
+            457,
+            805,
+            473
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural networks for machine learning, 4(2):26– 31, 2012. ",
+        "bbox": [
+            174,
+            481,
+            821,
+            523
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017. ",
+        "bbox": [
+            174,
+            531,
+            821,
+            575
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin Volker, Ji ¨ ˇr´ı Hammer, Robin T Schirrmeister, Joos Behncke, Lukas DJ Fiederer, Andreas Schulze-Bonhage, Petr Marusic, Wolfram Burgard, and Tonio Ball. Intracranial error detection ˇ via deep learning. arXiv preprint arXiv:1805.01667, 2018. ",
+        "bbox": [
+            176,
+            583,
+            825,
+            627
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jianfeng Wang, Ye Yuan, Gang Yu, and Sun Jian. Sface: An efficient network for face detection in large scale variations. arXiv preprint arXiv:1804.06559, 2018. ",
+        "bbox": [
+            173,
+            636,
+            823,
+            665
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ashia C Wilson, Rebecca Roelofs, Mitchell Stern, Nathan Srebro, and Benjamin Recht. The marginal value of adaptive gradient methods in machine learning. arXiv:1705.08292, 2017. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            702
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhudinov, Rich Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In International Conference on Machine Learning, pp. 2048–2057, 2015. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            753
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shuo Yang, Ping Luo, Chen-Change Loy, and Xiaoou Tang. Wider face: A face detection benchmark. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5525–5533, 2016. ",
+        "bbox": [
+            173,
+            762,
+            823,
+            805
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guodong Zhang, Chaoqi Wang, Bowen Xu, and Roger Grosse. Three mechanisms of weight decay regularization. arXiv preprint arXiv:1810.12281, 2018. ",
+        "bbox": [
+            169,
+            814,
+            823,
+            843
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zijun Zhang, Lin Ma, Zongpeng Li, and Chuan Wu. Normalized direction-preserving adam. arXiv:1709.04546, 2017. ",
+        "bbox": [
+            173,
+            852,
+            823,
+            881
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V. Le. Learning transferable architectures for scalable image recognition. In arXiv:1707.07012 [cs.CV], 2017. ",
+        "bbox": [
+            171,
+            890,
+            823,
+            919
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Appendix ",
+        "text_level": 1,
+        "bbox": [
+            449,
+            99,
+            549,
+            119
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A FORMAL ANALYSIS OF WEIGHT DECAY VS $\\mathrm { L _ { 2 } }$ REGULARIZATION",
+        "bbox": [
+            174,
+            136,
+            751,
+            155
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Proof of Proposition 1 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            169,
+            328,
+            183
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The proof for this well-known fact is straight-forward. SGD without weight decay has the following iterates on $\\begin{array} { r } { f _ { t } ^ { \\mathrm { r e g } } ( { \\pmb \\theta } ) = f _ { t } ( { \\pmb \\theta } ) + \\frac { \\lambda ^ { \\prime } } { 2 } \\left\\| { \\pmb \\theta } \\right\\| _ { 2 } ^ { 2 } } \\end{array}$ : ",
+        "bbox": [
+            173,
+            183,
+            823,
+            215
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/12cbf277b1d29cdc60da8debb02fb17bb5f24e120c7bda7e5413ec0f6fff36fd.jpg",
+        "text": "$$\n\\pmb { \\theta } _ { t + 1 }  \\pmb { \\theta } _ { t } - \\alpha \\nabla f _ { t } ^ { \\mathrm { r e g } } ( \\pmb { \\theta } _ { t } ) = \\pmb { \\theta } _ { t } - \\alpha \\nabla f _ { t } ( \\pmb { \\theta } _ { t } ) - \\alpha \\lambda ^ { \\prime } \\pmb { \\theta } _ { t } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            218,
+            678,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "SGD with weight decay has the following iterates on $f _ { t } ( \\pmb \\theta )$ : ",
+        "bbox": [
+            171,
+            238,
+            568,
+            253
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e07444167de97d4326d5c625942bbfcbff7568caef91f9008ebdd7becccf9e8d.jpg",
+        "text": "$$\n\\pmb { \\theta } _ { t + 1 }  ( 1 - \\lambda ) \\pmb { \\theta } _ { t } - \\alpha \\nabla f _ { t } ( \\pmb { \\theta } _ { t } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            257,
+            606,
+            275
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "These iterates are identical since $\\begin{array} { r } { \\lambda ^ { \\prime } = \\frac { \\lambda } { \\alpha } } \\end{array}$ ",
+        "bbox": [
+            176,
+            279,
+            444,
+            294
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Proof of Proposition 2 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            300,
+            330,
+            314
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Similarly to the Proof of Proposition 1, the iterates of $O$ without weight decay on $f _ { t } ^ { \\mathrm { r e g } } ( { \\pmb \\theta } ) = f _ { t } ( { \\pmb \\theta } ) +$ $\\begin{array} { r } { \\frac { 1 } { 2 } \\lambda ^ { \\prime } \\left. \\pmb { \\theta } \\right. _ { 2 } ^ { 2 } } \\end{array}$ and $O$ with weight decay $\\lambda$ on $f _ { t }$ are, respectively: ",
+        "bbox": [
+            173,
+            314,
+            820,
+            345
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8faff44faea95d8310f1550b2782f9d03233c188a9841efae0b3da3884a0ae66.jpg",
+        "text": "$$\n\\begin{array} { l l l } { \\pmb { \\theta } _ { t + 1 } } & {  } & { \\pmb { \\theta } _ { t } - \\alpha \\lambda ^ { \\prime } \\mathbf { M } _ { t } \\pmb { \\theta } _ { t } - \\alpha \\mathbf { M } _ { t } \\nabla f _ { t } ( \\pmb { \\theta } _ { t } ) . } \\\\ { \\pmb { \\theta } _ { t + 1 } } & {  } & { ( 1 - \\lambda ) \\pmb { \\theta } _ { t } - \\alpha \\mathbf { M } _ { t } \\nabla f _ { t } ( \\pmb { \\theta } _ { t } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            349,
+            647,
+            387
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The equality of these iterates for all $\\theta _ { t }$ would imply $\\lambda \\pmb { \\theta } _ { t } = \\alpha \\lambda ^ { \\prime } \\mathbf { M } _ { t } \\pmb { \\theta } _ { t }$ . This can only hold for all $\\theta _ { t }$ if $\\mathbf { M } _ { t } = k \\mathbf { I }$ , with $k \\in \\mathbb { R }$ , which is not the case for $O$ . Therefore, no $\\mathrm { L _ { 2 } }$ regularizer $\\lambda ^ { \\prime } \\left\\| \\pmb { \\theta } \\right\\| _ { 2 } ^ { 2 }$ exists that makes the iterates equivalent. □ ",
+        "bbox": [
+            174,
+            388,
+            825,
+            433
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Proof of Proposition 3 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            439,
+            330,
+            454
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "$O$ without weight decay has the following iterates on $\\begin{array} { r } { f _ { t } ^ { \\mathrm { s r e g } } ( \\pmb { \\theta } ) = f _ { t } ( \\pmb { \\theta } ) + \\frac { \\lambda ^ { \\prime } } { 2 } \\left\\| \\pmb { \\theta } \\odot \\sqrt { s } \\right\\| _ { 2 } ^ { 2 } ; } \\end{array}$ ",
+        "bbox": [
+            171,
+            454,
+            753,
+            473
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/beb754811806709c880ce130b08cd9f3bad3c04fd3e2baeaf9d596e8f48bbf67.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\pmb { \\theta } _ { t + 1 } } & {  } & { \\pmb { \\theta } _ { t } - \\alpha \\nabla f _ { t } ^ { \\mathrm { s r e g } } ( \\pmb { \\theta } _ { t } ) / s } \\\\ & { = } & { \\pmb { \\theta } _ { t } - \\alpha \\nabla f _ { t } ( \\pmb { \\theta } _ { t } ) / s - \\alpha \\lambda ^ { \\prime } \\pmb { \\theta } _ { t } \\odot s / s } \\\\ & { = } & { \\pmb { \\theta } _ { t } - \\alpha \\nabla f _ { t } ( \\pmb { \\theta } _ { t } ) / s - \\alpha \\lambda ^ { \\prime } \\pmb { \\theta } _ { t } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            476,
+            648,
+            531
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "where the division by $\\pmb { S }$ is element-wise. $O$ with weight decay has the following iterates on $f _ { t } ( \\pmb \\theta )$ : ",
+        "bbox": [
+            171,
+            532,
+            810,
+            547
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/41cca19e0ca33e70014a9795460fec9953a7d8ad306f9c85f673698dfc04c125.jpg",
+        "text": "$$\n\\begin{array} { r l r } { \\pmb { \\theta } _ { t + 1 } } & {  } & { ( 1 - \\lambda ) \\pmb { \\theta } _ { t } - \\alpha \\nabla f ( \\pmb { \\theta } _ { t } ) / s } \\\\ & { = } & { \\pmb { \\theta } _ { t } - \\alpha \\nabla f ( \\pmb { \\theta } _ { t } ) / s - \\lambda \\pmb { \\theta } _ { t } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            550,
+            622,
+            587
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "These iterates are identical since $\\begin{array} { r } { \\lambda ^ { \\prime } = \\frac { \\lambda } { \\alpha } } \\end{array}$ . ",
+        "bbox": [
+            176,
+            589,
+            444,
+            606
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B ADDITIONAL PRACTICAL IMPROVEMENTS OF ADAM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            625,
+            647,
+            641
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Having discussed decoupled weight decay for improving Adam’s generalization, in this section we introduce two additional components to improve Adam’s performance in practice. ",
+        "bbox": [
+            173,
+            655,
+            823,
+            684
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B.1 NORMALIZED WEIGHT DECAY",
+        "text_level": 1,
+        "bbox": [
+            176,
+            700,
+            429,
+            714
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Our preliminary experiments showed that different weight decay factors are optimal for different computational budgets (defined in terms of the number of batch passes). Relatedly, Li et al. (2017) demonstrated that a smaller batch size (for the same total number of epochs) leads to the shrinking effect of weight decay being more pronounced. Here, we propose to reduce this dependence by normalizing the values of weight decay. Specifically, we replace the hyperparameter $\\lambda$ by a new (more robust) normalized weight decay hyperparameter $\\lambda _ { n o r m }$ , and use this to set $\\lambda$ as $\\begin{array} { r } { \\lambda = \\lambda _ { n o r m } \\sqrt { \\frac { b } { B T } } } \\end{array}$ , where $b$ is the batch size, $B$ is the total number of training points and $T$ is the total number of epochs.2 Thus, $\\lambda _ { n o r m }$ can be interpreted as the weight decay used if only one batch pass is allowed. We emphasize that our choice of normalization is merely one possibility informed by few experiments; a more lasting conclusion we draw is that using some normalization can substantially improve results. ",
+        "bbox": [
+            173,
+            726,
+            825,
+            888
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B.2 ADAM WITH COSINE ANNEALING AND WARM RESTARTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            614,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We now apply cosine annealing and warm restarts to Adam, following the recent work of Loshchilov & Hutter (2016). There, the authors proposed Stochastic Gradient Descent with Warm Restarts (SGDR) to improve anytime performance of SGD by quickly cooling down the learning rate according to a cosine schedule and periodically increasing it. SGDR has been successfully adopted to lead to new state-of-the-art results for popular image classification benchmarks (Huang et al., 2017; Gastaldi, 2017; Zoph et al., 2017), and we therefore tried extending it to Adam. However, while our initial version of Adam with warm restarts had better anytime performance than Adam, it was not competitive with SGD with warm restarts, precisely because $\\mathrm { L _ { 2 } }$ regularization was not working as well as in SGD. Now, having fixed this issue by means of the original weight decay regularization (Section 2) and also having introduced normalized weight decay (Section B.1), the original work on cosine annealing and warm restarts by Loshchilov & Hutter (2016) directly carries over to Adam. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            284
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In the interest of keeping the presentation self-contained, we briefly describe how SGDR schedules the change of the effective learning rate in order to accelerate the training of DNNs. Here, we decouple the initial learning rate $\\alpha$ and its multiplier $\\eta _ { t }$ used to obtain the actual learning rate at iteration $t$ (see, e.g., line 8 in Algorithm 1). In SGDR, we simulate a new warm-started run/restart of SGD once $T _ { i }$ epochs are performed, where $i$ is the index of the run. Importantly, the restarts are not performed from scratch but emulated by increasing $\\eta _ { t }$ while the old value of $\\theta _ { t }$ is used as an initial solution. The amount by which $\\eta _ { t }$ is increased controls to which extent the previously acquired information (e.g., momentum) is used. Within the $i$ -th run, the value of $\\eta _ { t }$ decays according to a cosine annealing (Loshchilov & Hutter, 2016) learning rate for each batch as follows: ",
+        "bbox": [
+            174,
+            289,
+            825,
+            415
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6be3ae5693cc1f7e4cdd9c925b48f5909d54cedd42074f003f912c5c309135af.jpg",
+        "text": "$$\n\\eta _ { t } = \\eta _ { m i n } ^ { ( i ) } + 0 . 5 ( \\eta _ { m a x } ^ { ( i ) } - \\eta _ { m i n } ^ { ( i ) } ) ( 1 + \\cos ( \\pi T _ { c u r } / T _ { i } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            421,
+            660,
+            443
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "where η min and $\\eta _ { m a x } ^ { ( i ) }$ are ranges for the multiplier and $T _ { c u r }$ accounts for how many epochs have been performed since the last restart. $T _ { c u r }$ is updated at each batch iteration $t$ and is thus not constrained to integer values. Adjusting (e.g., decreasing) $\\eta _ { m i n } ^ { ( i ) }$ and $\\eta _ { m a x } ^ { ( i ) }$ at every $i$ -th restart (see also Smith (2016)) could potentially improve performance, but we do not consider that option here because it would involve additional hyperparameters. For $\\eta _ { m a x } ^ { ( i ) } = 1$ = 1 and η(i)min $\\eta _ { m i n } ^ { ( i ) } = 0$ , one can simplify Eq. (14) to ",
+        "bbox": [
+            173,
+            450,
+            825,
+            544
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/76dd7c1980f17fb581c4ecc823972c194f42282cdc024e747f844e301b969c19.jpg",
+        "text": "$$\n\\eta _ { t } = 0 . 5 + 0 . 5 \\cos ( \\pi T _ { c u r } / T _ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            550,
+            586,
+            568
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In order to achieve good anytime performance, one can start with an initially small $T _ { i }$ (e.g., from $1 \\%$ to $10 \\%$ of the expected total budget) and multiply it by a factor of $T _ { m u l t }$ (e.g., $T _ { m u l t } = 2$ ) at every restart. The $( i + 1 )$ -th restart is triggered when $T _ { c u r } = T _ { i }$ by setting $T _ { c u r }$ to 0. An example setting of the schedule multiplier is given in C. ",
+        "bbox": [
+            174,
+            574,
+            825,
+            631
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Our proposed AdamWR algorithm represents AdamW (see Algorithm 2) with $\\eta _ { t }$ following Eq. (15) and $\\lambda$ computed at each iteration using normalized weight decay described in the previous section. We note that normalized weight decay allowed us to use a constant parameter setting across short and long runs performed within AdamWR and SGDWR (SGDW with warm restarts). ",
+        "bbox": [
+            174,
+            637,
+            825,
+            694
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C AN EXAMPLE SETTING OF THE SCHEDULE MULTIPLIER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            713,
+            673,
+            731
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "An example schedule of the schedule multiplier $\\eta _ { t }$ is given in SuppFigure 1 for $T _ { i = 0 } = 1 0 0$ and $T _ { m u l t } = 2$ . After the initial 100 epochs the learning rate will reach 0 because $\\eta _ { t = 1 0 0 } = 0$ . Then, since $T _ { c u r } = T _ { i = 0 }$ , we restart by resetting $T _ { c u r } = 0$ , causing the multiplier $\\eta _ { t }$ to be reset to 1 due to Eq. (15). This multiplier will then decrease again from 1 to 0, but now over the course of 200 epochs because $T _ { i = 1 } = T _ { i = 0 } T _ { m u l t } = 2 0 0$ . Solutions obtained right before the restarts, when $\\eta _ { t } = 0$ (e.g., at epoch indexes 100, 300, 700 and 1500 as shown in SuppFigure 1) are recommended by the optimizer as the solutions, with more recent solutions prioritized. ",
+        "bbox": [
+            173,
+            744,
+            825,
+            843
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D ADDITIONAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            864,
+            400,
+            880
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We investigated whether the use of much longer runs (1800 epochs) of “standard Adam” (Adam with $\\mathrm { L _ { 2 } }$ regularization and a fixed learning rate) makes the use of cosine annealing unnecessary. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/05aeac11b243ee1c9b6ee060aff58ac2592760fb64cd2d49c797565303ec0f23.jpg",
+        "image_caption": [
+            "SuppFigure 1: An example schedule of the learning rate multiplier as a function of epoch index. The first run is scheduled to converge at epoch $T _ { i = 0 } ~ = ~ 1 0 0$ , then the budget for the next run is doubled as $T _ { i = 1 } = T _ { i = 0 } T _ { m u l t } = 2 0 0$ , etc. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            341,
+            113,
+            650,
+            296
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "SuppFigure 2 shows the results of standard Adam for a 4 by 4 logarithmic grid of hyperparameter settings (the coarseness of the grid is due to the high computational expense of runs for 1800 epochs). Even after taking the low resolution of the grid into account, the results appear to be at best comparable to the ones obtained with AdamW with 18 times less epochs and a smaller network (see SuppFigure 3, top row, middle). These results are not very surprising given Figure 2 in the main paper (which demonstrates the effectiveness of AdamW) and SuppFigure 1 (which demonstrates the necessity to use some learning rate schedule such as cosine annealing). ",
+        "bbox": [
+            174,
+            380,
+            825,
+            477
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Our experimental results with Adam and SGD suggested that the total runtime in terms of the number of epochs affect the basin of optimal hyperparameters (see SuppFigure 3). More specifically, the greater the total number of epochs the smaller the values of the weight decay should be. SuppFigure 4 shows that our remedy for this problem, the normalized weight decay defined in Eq. (15), simplifies hyperparameter selection because the optimal values observed for short runs are similar to the ones for much longer runs. We used our initial experiments on CIFAR-10 to suggest the square root normalization we proposed in Eq. (15) and double-checked that this is not a coincidence on the ImageNet32x32 dataset (Chrabaszcz et al., 2017), a downsampled version of the original ImageNet dataset with 1.2 million $3 2 \\times 3 2$ pixels images, where an epoch is 24 times longer than on CIFAR-10. This experiment also supported the square root scaling: the best values of the normalized weight decay observed on CIFAR-10 represented nearly optimal values for ImageNet32x32 (see SuppFigure 3). In contrast, had we used the same raw weight decay values $\\lambda$ for ImageNet32x32 as for CIFAR10 and for the same number of epochs, without the proposed normalization, $\\lambda$ would have been roughly 5 times too large for ImageNe $3 2 x 3 2$ , leading to much worse performance. The optimal normalized weight decay values were also very similar (e.g., $\\lambda _ { n o r m } = 0 . 0 2 5$ and $\\lambda _ { n o r m } = 0 . 0 5 )$ ) across SGDW and AdamW. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            705
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "SuppFigure 4 is the equivalent of Figure 3 in the main paper, but for ImageNet32x32 instead of for CIFAR-10. The qualitative results are identical: weight decay leads to better training loss (crossentropy) than $\\mathrm { L _ { 2 } }$ regularization, and to an even greater improvement of test error. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            756
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "SuppFigure 5 and SuppFigure 6 are the equivalents of Figure 4 in the main paper but supplemented with training loss curves in its bottom row. The results show that Adam and its variants with decoupled weight decay converge faster (in terms of training loss) on CIFAR-10 than the corresponding SGD variants (the difference for ImageNet32x32 is small). As is discussed in the main paper, when the same values of training loss are considered, AdamW demonstrates better values of test error than Adam. Interestingly, SuppFigure 5 and SuppFigure 6 show that restart variants AdamWR and SGDWR also demonstrate better generalization than AdamW and SGDW, respectively. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            859
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/d61e04f283fa31f4651067bc40c835a7e0d1c6120984b5b1ce501d36ef00cee2.jpg",
+        "image_caption": [
+            "SuppFigure 2: Performance of “standard Adam”: Adam with $\\mathrm { L _ { 2 } }$ regularization and a fixed learning rate. We show the final test error of a $2 6 ~ 2 \\mathrm { x } 9 6 \\mathrm { d }$ ResNet on CIFAR-10 after 1800 epochs of the original Adam for different settings of learning rate and weight decay used for $\\mathrm { L _ { 2 } }$ regularization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            343,
+            359,
+            656,
+            604
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/dd04a2ab90cfc312d3ac98c8dc68782db24031d7719e24db29f24240372c8b49.jpg",
+        "image_caption": [
+            "SuppFigure 3: Effect of normalized weight decay. We show the final test Top-1 error on CIFAR10 (first two rows for AdamW without and with normalized weight decay) and Top-5 error on ImageNet32x32 (last two rows for AdamW and SGDW, both with normalized weight decay) of a $2 6 2 \\mathrm { x } 6 4 \\mathrm { d }$ ResNet after different numbers of epochs (see columns). While the optimal settings of the raw weight decay change significantly for different runtime budgets (see the first row), the values of the normalized weight decay remain very similar for different budgets (see the second row) and different datasets (here, CIFAR-10 and ImageNet32x32), and even across AdamW and SGDW. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            125,
+            797,
+            779
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/cae7758f0603d244c6a3533a4e7895f997ffe6ec31c9bfd389ed44477fe94759.jpg",
+        "image_caption": [
+            "SuppFigure 4: Learning curves (top row) and generalization results (Top-5 errors in bottom row) obtained by a $2 6 2 \\mathrm { x } 9 6 \\mathrm { d }$ ResNet trained with Adam and AdamW on ImageNet32x32. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            292,
+            803,
+            688
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/5ab029b7e35779e3bea2ccd6ef38c9aa1439a43f3f4434a679a70961745062d0.jpg",
+        "image_caption": [
+            "SuppFigure 5: Test error curves (top row) and training loss curves (bottom row) for CIFAR-10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            118,
+            764,
+            867
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/1eca1bdf2cf4c17312faab960a100d5dd1708b424add1e9f49f170d4725df754.jpg",
+        "image_caption": [
+            "SuppFigure 6: Test error curves (top row) and training loss curves (bottom row) for ImageNet32x32. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            169,
+            103,
+            761,
+            854
+        ],
+        "page_idx": 17
+    }
+]

parse/train/SJMnG2C9YX/SJMnG2C9YX.md

@@ -0,0 +1,298 @@
+# COMPLEMENTARY-LABEL LEARNING FOR ARBITRARY LOSSES AND MODELS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+In contrast to the standard classification paradigm where the true (or possibly noisy) class is given to each training pattern, complementary-label learning only uses training patterns each equipped with a complementary label. This only specifies one of the classes that the pattern does not belong to. The seminal paper on complementary-label learning proposed an unbiased estimator of the classification risk that can be computed only from complementarily labeled data. However, it required a restrictive condition on the loss functions, making it impossible to use popular losses such as the softmax cross-entropy loss. Recently, another formulation with the softmax cross-entropy loss was proposed with consistency guarantee. However, this formulation does not explicitly involve a risk estimator. Thus model/hyper-parameter selection is not possible by cross-validation— we may need additional ordinarily labeled data for validation purposes, which is not available in the current setup. In this paper, we give a novel general framework of complementary-label learning, and derive an unbiased risk estimator for arbitrary losses and models. We further improve the risk estimator by non-negative correction and demonstrate its superiority through experiments.
+
+# 1 INTRODUCTION
+
+Modern classification methods usually require massive data with high-quality labels, but preparing such datasets is unrealistic in many practical domains. To mitigate the problem, many previous works have investigated ways to learn from weak supervision: semi-supervised learning (Chapelle et al., 2006; Miyato et al., 2016; Kipf & Welling, 2017; Sakai et al., 2017; Tarvainen & Valpola, 2017; Oliver et al., 2018), learning from noisily-labeled data (Natarajan et al., 2013; Patrini et al., 2017; Ma et al., 2018), learning from positive-unlabeled data (Elkan & Noto, 2008; du Plessis et al., 2014; 2015; Kiryo et al., 2017), learning from similar-unlabeled data (Bao et al., 2018), learning from positive-confidence data (Ishida et al., 2018), and others.
+
+In this paper, we consider learning from another type of weak but natural supervision called complementary-label learning (Ishida et al., 2017; Yu et al., 2018), where the label only specifies one of the classes that the pattern does not belong to. In contrast to the ordinary case where the true class is given to each pattern (which often needs to be chosen out of many candidate classes precisely), collecting these complementary labels is obviously much easier and less costly. A natural question is, however, is it possible to learn from such complementary labels (without any true labels)?
+
+The problem has previously been tackled by Ishida et al. (2017), showing that the classification risk can be recovered only from complementarily labeled data. They also gave consistency gaurantee in theoretical analysis. However, they required strong restrictions on the loss functions, allowing only one-versus-all and pairwise comparison multi-class loss functions (Zhang, 2004) with certain non-convex binary losses. This is a severe limitation when we use deep learning since the softmax cross-entropy loss is often used to boost the classification performance.
+
+Later, Yu et al. (2018) proposed a different formulation for complementary labels by employing the forward loss correction technique (Patrini et al., 2017) to adjust the learning objective. Their proposed risk estimator is not necessarily unbiased but the minimizer is theoretically guaranteed to be consistent with the minimizer of the risk for ordinary labels (under an implicit assumption on the model for convergence analysis).
+
+Table 1: Comparison of two proposed complementary-label methods with previous works.   
+
+<table><tr><td>Methods</td><td>loss assump. free</td><td>model assump. free</td><td>unbiased estimator</td><td>explicit risk correction</td></tr><tr><td>Ishida et al. (2017)</td><td>×</td><td>√</td><td>√</td><td>×</td></tr><tr><td>Yu et al. (2018)</td><td>×</td><td>×</td><td>×</td><td>×</td></tr><tr><td>Proposed (General formulation)</td><td></td><td>√</td><td>√</td><td></td></tr><tr><td>Proposed (Non-negative formulation)</td><td>√</td><td></td><td>×</td><td>×</td></tr></table>
+
+They also extended the problem setting to where complementary labels are chosen in an uneven (biased) way. This is a realistic problem setting because labelers are more likely to complementarily label a pattern when they feel it is not a certain class which they have more knowledge or experience about.
+
+In this paper, we first derive an unbiased risk estimator with a general loss function, making any loss functions available for use: not only the softmax cross-entropy loss function but other convex/nonconvex loss functions can also be applied. We also do not have implicit assumptions on the classifier, allowing both linear and non-linear models.
+
+Yu et al. (2018) does not have an unbiased risk estimator, which means users will need clean data with true labels to calculate the error rate during the validation process. On the other hand, our proposed unbiased risk estimator can handle complementarily labeled validation data not only for our learning objective, but also for Yu et al. (2018). This is helpful since collecting clean data is usually much more expensive.
+
+Finally, our proposed unbiased risk estimator has an issue that it is unbounded from below and suffers from the classification risk going to negative after learning, leading to overfitting. We further propose a non-negative correction to the original unbiased risk estimator to improve our estimator. We experimentally show that our proposed method is comparable to or better than previous methods (Ishida et al., 2017; Yu et al., 2018) in terms of classification accuracy.
+
+# 2 REVIEW OF PREVIOUS WORKS
+
+In this section, we explain the notations and review the formulations of learning from ordinary labels, learning from complementary labels, and learning from both ordinary and complementary labels.
+
+Learning from ordinary labels Let $\mathcal { X }$ be an instance space and $\mathcal { D }$ be the joint distribution over $\mathcal { X } \times [ K ]$ for class label set $[ K ] : = \{ 1 , 2 , \dots , K \}$ , with random variables $( { \bar { X } } , Y ) \sim { \mathcal { D } }$ . The data at hand is sampled inThe joint distribution pendently and identically from the joint distributiocan be either decomposed into class-conditionals $\{ ( x _ { i } , y _ { i } ) \} _ { i = 1 } ^ { n } \stackrel { \mathrm { i . i . d . } } { \sim } \mathcal { D }$ $\mathcal { D }$ $\{ P _ { k } \} _ { k = 1 } ^ { K }$ $\{ \pi _ { k } \} _ { k = 1 } ^ { K }$ , where $P _ { k } : = \mathbb { P } ( X | Y = k )$ and $\pi _ { k } : = \mathbb { P } ( Y = k )$ , or the marginal $M$ and class-probability function $\eta : \mathcal { X } \ :  \ : \Delta _ { k }$ , where $M : = \mathbb { P } ( X )$ and $\pmb { \eta } _ { k } ( x ) : = \mathbb { P } ( Y = \pmb { k } | X = x )$ . A loss is any $\ell : [ K ] \times \mathbb { R } ^ { K } \to \mathbb { R } _ { + }$ and the decision function is any $g : \mathcal { X } \overset { } {  } \mathbb { R } ^ { K }$ . The risk for the decision function $\textbf {  { g } }$ with respect to loss $\ell$ and implicit distribution $\mathcal { D }$ is:
+
+$$
+R ( g ; \ell ) : = \mathbb { E } _ { ( X , Y ) \sim \mathcal { D } } [ \ell ( Y , \pmb { g } ( X ) ) ] ,
+$$
+
+where $\mathbb { E }$ denotes the expectation. Two useful equivalent expressions of classification risk (1) used in later sections are
+
+$$
+R ( g ; \ell ) : = \mathbb { E } _ { X } [ \eta ( x ) ^ { T } \ell ( { \pmb g } ( X ) ) ] = \sum _ { k = 1 } ^ { K } \pi _ { k } \mathbb { E } _ { \mathbb { P } _ { k } } \Big [ \ell ( k , { \pmb g } ( X ) ) \Big ] ,
+$$
+
+where $\ell : = [ \ell ( 1 , \pmb { g } ) , \ell ( 2 , \pmb { g } ) , \dots , \ell ( K , \pmb { g } ) ] ^ { T }$ . The goal of classification is to learn the decision function that minimizes the risk. In the usual classification case with ordinarily labeled data at hand, approximating the risk empirically is straightforward: $\begin{array} { r } { \widehat { R } ( g ; \ell ) : = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \ell ( y _ { i } , g ( x _ { i } ) ) } \end{array}$ .
+
+Learning from complementary labels Next we consider the problem of learning from complementary labels (Ishida et al., 2017). We observe patterns each equipped with a complementary label $\{ ( x _ { i ^ { \prime } } , \stackrel { \cdot } { y } _ { i ^ { \prime } } ) \} _ { i ^ { \prime } = 1 } ^ { n ^ { \prime } }$ sampled independently and identically from a different joint distribution $\overline { { \mathcal { D } } } \neq \mathcal { D }$ . We denote random variables as $( X , { \overline { { Y } } } ) \sim { \overline { { \mathcal { D } } } }$ . As before, we assume this distribution can be decomposed into either class-conditionals $\{ \overline { { P } } _ { k } \} _ { k = 1 } ^ { K }$ and base rate $\{ \overline { { \pi } } \} _ { k = 1 } ^ { K }$ , or marginal $M$ and classprobability function $\overline { { \eta } } : \mathcal { X } \to \Delta _ { K }$ , where ${ \overline { { P } } } _ { k } : = \mathbb { P } ( X | { \overline { { Y } } } = k )$ , $\overline { { \pi } } _ { k } : = \mathbb { P } ( \overline { { Y } } = k )$ , $M : = \mathbb { P } ( X )$ , $\overline { { \eta } } _ { k } ( x ) : = \mathbb { P } ( \overline { { Y } } = k | X = x )$ , $\overline { { Y } }$ is the complementary label, and $\Delta _ { K }$ is the conditional probability simplex for $K$ classes. Without any assumptions on $\overline { { \mathcal { D } } }$ , it is impossible to design a suitable learning procedure. The assumption for unbiased complementary learning used in Ishida et al. (2017) was
+
+$$
+\overline { { { \eta } } } ( \boldsymbol { x } ) = T \eta ( \boldsymbol { x } ) ,
+$$
+
+where $\pmb { T } \in \mathbb { R } ^ { K \times K }$ is a matrix that takes 0 on diagonals and $\frac { 1 } { K - 1 }$ on non-diagonals. Under this assumption, Ishida et al. (2017) proved that they can recover the classification risk (1) from an alternative formulation using only complementarily labeled data when he loss function satisfies certain conditions. More specifically, usable loss functions are pairwise comparison or one-versus-all multi-class loss functions (Zhang, 2004) each with binary loss function $\ell ^ { \bar { \prime } } ( z ) : \mathbb { R } \to \mathbb { R } _ { + }$ that satisfies $\ell ^ { \prime } ( z ) + \ell ^ { \prime } ( - z ) = 1$ , such as ramp loss $\begin{array} { r } { \ell _ { R } ^ { \prime } ( z ) = \frac { 1 } { 2 } \operatorname* { m a x } \left( 0 , \operatorname* { m i n } ( 2 , 1 - z ) \right) } \end{array}$ or sigmoid loss ℓ′S (z ) = 11+ez .
+
+Having an unbiased risk estimator is also helpful for the validation process. Since we do not have ordinary labels in our validation set in the complementary-label learning setting, we cannot follow the usual validation procedure that uses zero-one error or accuracy. If we have an unbiased estimator of the original classification risk (which can be interpreted as zero-one error), we can use the empirical risk for (cross)-validated complementary data to select the best hyper-parameter or deploy early stopping.
+
+An extension of the above method was considered in Yu et al. (2018) by using a different assumption than the unbiased complementary learning of Ishida et al. (2017): there is some bias amongst the possible complementary labels that can be chosen, thus the non-diagonals of $_ { \mathbf { T } }$ is not restricted to $\frac { 1 } { K - 1 }$ . However, one will need to prepare a separate dataset with ordinary labels in order to estimate $_ { \mathbf { T } }$ beforehand.
+
+Unlike Ishida et al. (2017), Yu et al. (2018) did not directly provide a risk estimator, but they showed that the minimizer of their learning objective agrees with the minimizer of the original classification risk (1). Note that, in their formulation, the loss function is restricted to the softmax cross-entropy loss. Furthermore, the use of a highly non-linear model is supposed for consistency guarantee in their theoretical analysis. Since the learning objective of $\mathrm { Y u }$ et al. (2018) does not correspond to the classification risk, one will need clean data with true labels to calculate the error rate during the validation process. On the other hand, our proposed risk estimator can cope with complementarily labeled validation data not only for our own learning objective, but can be used to select hyperparameters for others such as Yu et al. (2018).
+
+Learning from both ordinary and complementary labels In many practical situations, we may also have ordinarily labeled data in addition to complementarily labeled data. Ishida et al. (2017) touched on the idea of crowdsourcing for an application with both types of data. For example, we may choose one of the classes randomly by following the uniform distribution, with probability $\frac { 1 } { K - 1 }$ for each class, and ask crowdworkers whether a pattern belongs to the chosen class or not. Then the pattern is treated as ordinarily labeled if the answer is yes; otherwise, the pattern is regarded as complementarily labeled. If the true label was $y$ for a pattern, we can naturally assume that the crowdworker will answer yes by $\mathbb { P } ( Y = y | X = \overset { \cdot } { x } )$ and no by $1 - \mathbb { P } ( Y = y | X \mathbf { \hat { = } } x )$ . This way, ordinarily labeled data can be regarded as samples from $\mathcal { D }$ , and complementarily labeled data from $\overline { { \mathcal { D } } }$ , justifying the assumption of unbiased complementary learning (3). In Ishida et al. (2017), they considered a convex combination of the classification risks derived from ordinarily labeled data and complementarily labeled data: $\alpha R ( g ; \overline { { \ell } } ) + ( 1 - \alpha ) R ( g ; \ell )$ , where $\alpha \in [ 0 , 1 ]$ is a hyper-parameter that interpolates between the two risks. The combined (also unbiased) risk estimator can utilize both kinds of data in order to obtain better classifiers, which was demonstrated to perform well in experiments.
+
+# 3 PROPOSED METHOD
+
+As discussed in the previous section, the method by Ishida et al. (2017) works well in practice, but it has restriction on the loss functions—the popular softmax cross-entropy loss is not allowed. On the other hand, the method by Yu et al. (2018) allows us to use the softmax cross-entropy loss, but it does not directly provide an estimator of the classification risk and thus model selection is problematic in practice. We first describe our general unbiased risk formulation in Section 3.1. Then we discuss how the estimator can be further improved in Section 3.2. Third, we propose a way for our risk estimator to avoid overfitting by a non-negative risk estimator in Section 3.3. Finally, we show practical implementation of our risk estimator with stochastic optimization methods in Section 3.4.
+
+# 3.1 GENERAL RISK FORMULATION
+
+First, we describe our general unbiased risk formulation. We give the following theorem, which allows unbiased estimation of the classification risk from complementarily labeled samples:
+
+Theorem 1. For any ordinary distribution $\mathcal { D }$ and complementary distribution $\overline { { \mathcal { D } } }$ related by (3) with decision function $\textbf {  { g } }$ , and loss $\ell$ , we have
+
+$$
+R ( \pmb { g } ; \ell ) = R ( \pmb { g } ; \bar { \ell } )
+$$
+
+for the complementary loss
+
+$$
+\overline { { \ell } } ( \pmb { g } ) : = \Big ( - ( K - 1 ) \pmb { I } _ { K } + \frac { 1 } { K - 1 } \pmb { 1 } \pmb { 1 } ^ { \top } \Big ) \cdot \pmb { \ell } ( \pmb { g } ) ,
+$$
+
+where 1 is a A. The key $K$ -dimensional column vector with 1 in each ela of the proof is to not rely on the condition e found in Appendix used in Ishida et al. $\begin{array} { r } { \sum _ { k = 1 } ^ { K } \overline { { \ell } } ( k , g ) = 1 } \end{array}$ (2017), which is a condition inspired by the property of binary 0-1 loss $\ell _ { 0 - 1 }$ , where if $z < 0$ and 0 otherwise. Note that such a technique was also used when designing unbiased risk estimators for learning from positive and unlabeled data in a binary classification setup (?), but was later shown to be unnecessary (du Plessis et al., 2015).
+
+According to Theorem 1, we can derive an equivalent form,
+
+$$
+\boldsymbol { \overline { { \ell } } } ( \boldsymbol { k } , g ) = - ( K - 1 ) \cdot \boldsymbol { \ell } ( \boldsymbol { k } , g ) + \sum _ { j = 1 } ^ { K } \boldsymbol { \ell } ( j , g ) .
+$$
+
+Therefore, the classification risk can be written as
+
+$$
+R ( g ; \ell ) = \sum _ { k = 1 } ^ { K } \overline { { { \pi } } } _ { k } \mathbb { E } _ { \overline { { { P } } } _ { k } } \Big [ - ( K - 1 ) \cdot \ell ( k , g ) + \sum _ { j = 1 } ^ { K } \ell ( j , g ) \Big ] .
+$$
+
+This expression of the classification risk allows us to naively approximate it in an unbiased fashion using complementarily labeled data as
+
+$$
+\widehat { R } ( g ; \ell ) = \sum _ { k = 1 } ^ { K } \frac { \widehat { \pi } _ { k } } { n _ { k } } \sum _ { i = 1 } ^ { n _ { k } } \Big [ - ( K - 1 ) \cdot \ell \big ( k , g ( \pmb { x } _ { i } ) \big ) + \sum _ { j = 1 } ^ { K } \ell ( j , g \big ( \pmb { x } _ { i } \big ) \big ) \Big ] ,
+$$
+
+where $n _ { k }$ is the number of samples complementarily labeled as the $k$ th class. It is worth noting that, in the above derivation, there are no constraints on the loss function and classifier. Thus, we can use any convex/non-convex loss and any linear/non-linear parametric/non-parametric model for complementary learning.
+
+# 3.2 NECESSITY OF RISK CORRECTION
+
+The original expression of the classification risk (1) includes an expectation over non-negative loss $\ell : [ K ] \times \mathbb { R } ^ { K } \overset { \cdot } {  } \mathbb { R } _ { + }$ , so the risk and its empirical approximator are both lower-bounded by zero. On the other hand, the expression (7) derived above contains an negative element. Although (7) is still non-negative by definition, due to the negative term, its empirical estimator can go negative, leading to over-fitting.
+
+![](images/2c0b3b6c6c254c771a08350f3b0ac953c987ce742855b305c3cfabbf17657d04.jpg)  
+Figure 1: The left and middle graphs shows the total risk (8) (in black color) and the risk decomposed into each ordinary class term (9) (in other colors) for training data with linear and MLP models, respectively. As an MLP model, a one-hidden-layer neural network with 500 units was used, with $R e L U$ (Nair & Hinton, 2010) as the activation function, Adam (Kingma & Ba, 2015) for optimization with learning rate $5 e - 5$ and weight decay of $1 e - 4$ . The right graph shows the corresponding test accuracy for both models.
+
+We elaborate on this issue with an illustrative numerical example. In the left graph of Figure 1, we show an example of training a linear model trained on the handwritten digits dataset $\mathrm { \bf M N I S T ^ { 1 } }$ , with complementary labels generated to satisfy (3). We used Adam (Kingma & Ba, 2015) for optimization with learning rate $5 e - 5$ , and weight decay of $1 e - 4$ with 300 epochs. The empirical classification risk (8) is shown in black. We can see that the empirical classification risk continues decreasing and can go below zero at around 100 epochs. The test accuracy on the right graph hits the peak also at around epoch 100 and then the accuracy gradually deteriorates.
+
+This issue stands out even more significantly when we use a flexible model. The middle graph shows the empirical classification risk for a multilayer perceptron (MLP) with one hidden layer (500 units), where ReLU (Nair & Hinton, 2010) was used as the activation function. The optimization setup was the same as the case of the linear model above. We can see the empirical risk decreasing much more quickly and going negative. Correspondingly, as the right graph shows, the test accuracy drops significantly after the empirical risk goes negative.
+
+In fact, a similar issue has already been conceivable in the original paper by Ishida et al. (2017): According to Theorem 1 in Ishida et al. (2017), the unbiased risk estimator includes subtraction of a positive constant term which increases with respect to the number of classes. This means that the learning objective of Ishida et al. (2017) has a (negative) lower bound. Our objective, however, is unbounded from below and thus can end up in even heavier overfitting.
+
+# 3.3 NON-NEGATIVE RISK ESTIMATOR
+
+As we saw in Section 3.2, our risk estimator can suffer from overfitting due to the non-negative issue. Here, we propose a correction to the risk estimator to overcome this problem.
+
+Each term in the risk with ordinary labels (right-hand side of (2)), which corresponds to each class, is non-negative. We can reformulate (7) in order to show the counterpart for each non-negative term in right-hand side of (2) for complementarily labeled data as
+
+$$
+R ( g ; \ell ) = \sum _ { k = 1 } ^ { K } \overline { { \pi } } _ { k } \Big [ - ( K - 1 ) \cdot \mathbb { E } _ { \overline { { P } } _ { k } } [ \ell ( k , g ) ] + \sum _ { j = 1 } ^ { K } \mathbb { E } _ { \overline { { P } } _ { j } } [ \ell ( k , g ) ] \Big ] .
+$$
+
+These counterparts (9) were originally non-negative when ordinary labels were used. In the left and middle graphs of Figure 1, we plot the decomposed risk with respect to each ordinary class (9) (shown in different colors). We can see that the decomposed risks for all classes become negative eventually. Based on this observation, our basic idea for correction is to enforce non-negativity for each ordinary class, with the expression based on complementary labels. More specifically, we propose a non-negative (nn) version by
+
+$$
+R _ { \mathrm { n n } } ( g ; \ell ) = \sum _ { k = 1 } ^ { K } \operatorname* { m a x } \Big \{ 0 , \overline { { \pi } } _ { k } \Big [ - ( K - 1 ) \cdot \mathbb { E } _ { \overline { { P } } _ { k } } [ \ell ( k , g ) ] + \sum _ { j = 1 } ^ { K } \mathbb { E } _ { \overline { { P } } _ { j } } [ \ell ( k , g ) ] \Big ] \Big \} .
+$$
+
+This non-negative risk can be naively approximated by the sample average as
+
+$$
+\widehat { R } _ { \mathrm { n n } } ( g ; \ell ) = \sum _ { k = 1 } ^ { K } \operatorname* { m a x } \Big \{ 0 , \pi \Big [ - \frac { K - 1 } { n _ { k } } \sum _ { i = 1 } ^ { n _ { k } } \ell ( k , g ( x _ { i } ) ) + \sum _ { j = 1 } ^ { K } \frac { 1 } { n _ { i ^ { \prime } } } \sum _ { i ^ { \prime } = 1 } ^ { n _ { i ^ { \prime } } } \ell ( j , g ( x _ { i ^ { \prime } } ) ) \Big ] \Big \} .
+$$
+
+Enforcing the reformulated risk to become non-negative was previously explored in Kiryo et al. (2017), in the context of binary classification from positive and unlabeled data. The positive class risk is already bounded below by zero in their case (because they have true positive labels), so there was a max operator only on the negative class risk. We basically follow their footsteps, but since our setting is a multi-class scenario and also differs by not having any true labels, we put a max operator on every $K$ class.
+
+# 3.4 IMPLEMENTATION
+
+Implementation with max operator We show practical implementation under stochastic optimization for our non-negative risk estimator. An unfortunate issue is that the minimization of (11) is not point-wise due to the max-operator, thus cannot be used directly for stochastic optimization methods with mini-batch. However, an upper bound of the risk can be minimized in parallel by using mini-batch as the following,
+
+$$
+\frac { 1 } { N } \sum _ { i = 1 } ^ { N } \sum _ { k = 1 } ^ { K } \operatorname* { m a x } \Big \{ 0 , \pi _ { k } \Big [ - ( K - 1 ) \widehat { \mathbb { E } } _ { \overline { { P } } _ { k } } [ \ell ( k , g ) ; \mathcal { X } _ { \widehat { k } } ^ { i } ] + \sum _ { j = 1 } ^ { K } \widehat { \mathbb { E } } _ { \overline { { P } } _ { j } } [ \ell ( k , g ) ; \mathcal { X } _ { \widehat { j } } ^ { i } ] \Big ] \Big \} ,
+$$
+
+where $\widehat { \mathbb { E } }$ is the empirical version of the expectation and $\mathcal { X } _ { \overline { { j } } } ^ { i }$ denotes the samples complementarily labeled as the $j$ th class in the ith mini-batch.
+
+Implementation with gradient ascent If the objective is negative for a certain mini-batch, the previous implementation based on the max operator will avoid the objective to further decrease. However, if the objective is already negative, that mini-batch has already started to overfit. Therefore, it would be preferable to increase itself to make this mini-batch less overfitted.
+
+Our idea is the following. We denote the risk that corresponds to the $k$ th ordinary class for the ith mini-batch as
+
+$$
+r _ { k } ^ { i } ( \theta ) = \overline { { \pi } } _ { k } \big [ - ( K - 1 ) \widehat { \mathbb { E } } _ { \overline { { P } } _ { k } } [ \ell ( k , g ) ; \mathcal { X } _ { \overline { { k } } } ^ { i } ] + \sum _ { j = 1 } ^ { K } \widehat { \mathbb { E } } _ { \overline { { P } } _ { j } } [ \ell ( k , g ) ; \mathcal { X } _ { \overline { { j } } } ^ { i } ] \big ] ,
+$$
+
+and the total risk as $\begin{array} { r } { L ^ { i } ( \theta ) = \sum _ { k = 1 } ^ { K } r _ { k } ^ { i } ( \theta ) } \end{array}$ . When $\mathrm { m i n } _ { k } \{ r _ { k } ^ { i } ( \theta ) \} _ { k = 1 } ^ { K } \geq - \beta$ , we conduct gradient descent as usual with gradient $\nabla _ { \theta } L ^ { i } ( \theta )$ . On the other hand, if $\mathrm { m i n } _ { k } \{ r _ { k } ^ { i } ( \theta ) \} _ { k = 1 } ^ { K } < - \beta$ , we first squash the class-decomposed risks over $- \beta$ to $- \beta$ with a min operator, and then sum the results: $\begin{array} { r } { \tilde { L ^ { i } } ( \theta ) = \sum _ { k = 1 } ^ { K } \operatorname* { m i n } \{ - \bar { \beta } , r _ { k } ^ { i } ( \theta ) \} , } \end{array}$ .
+
+Next we set the gradient in the opposite direction with $- \nabla _ { \boldsymbol { \theta } } \widetilde { L } ^ { i } ( \boldsymbol { \theta } )$ . Conceptually, we are going up the gradient $\nabla _ { \boldsymbol { \theta } } \widetilde { L } ^ { i } ( { \boldsymbol { \theta } } )$ for only the class-decomposed risks below $- \beta$ , to avoid the class-decomposed risks that are already large to further increase. Note that $\beta$ is a hyper-parameter that controls the tolerance of negativity. $\beta = 0$ would mean there is zero tolerance, but in practice we can also have $- \beta \neq 0$ for a threshold that allows some negative ${ \mathit { \Omega } } ^ { \prime } - \beta < 0 { \mathit { \Gamma } }$ or positive $( - \beta > 0 )$ ) amount. The procedure is shown in detail in Algorithm 1.
+
+# 4 EXPERIMENTS
+
+In this section, we experimentally compare our three proposed methods (Algorithm 1, (8) and (12), with two baseline methods from Ishida et al. (2017) and Yu et al. (2018). Table 2 describes the summary statistics of the benchmark datasets used in this section. The implementation is based on Pytorch2 and our code will be available on http://anonymized for reproducing results.
+
+Input: complementarily labeled training data $\{ \mathcal { X } _ { \overline { { k } } } \} _ { \overline { { k } } = 1 } ^ { K }$ , where ${ \mathit { X } } _ { \overline { { k } } }$ denotes the samples comple  
+mentarily labeled as class $\overline { { k } }$ ;   
+Output: model parameter $\theta$ for $g ( { \pmb x } ; { \boldsymbol \theta } )$   
+1: Let $\mathcal { A }$ be an external SGD-like stochastic optimization algorithm such as Kingma & Ba (2015)   
+2: Denote $\{ \mathcal { X } _ { \overline { { j } } } ^ { i } \}$ as the $i$ -th mini-batch for complementary class $j$   
+3: Denote $\begin{array} { r } { L ^ { i } ( \theta ) = \sum _ { k = 1 } ^ { K } r _ { k } ^ { i } ( \theta ) } \end{array}$   
+4: Denote $\begin{array} { r } { r _ { k } ^ { i } ( \theta ) = \overline { { \pi } } _ { k } \widetilde { \big [ } - ( K - 1 ) \widehat { \mathbb { E } } _ { \overline { { P } } _ { k } } [ \ell ( k , g ) ; \mathcal { X } _ { \overline { { k } } } ^ { i } ] + \sum _ { j = 1 } ^ { K } \widehat { \mathbb { E } } _ { \overline { { P } } _ { j } } [ \ell ( k , g ) ; \mathcal { X } _ { \overline { { j } } } ^ { i } ] \big ] } \end{array}$   
+5: Denote $\begin{array} { r } { \widetilde L ^ { i } ( \theta ) = \sum _ { k = 1 } ^ { K } \operatorname* { m i n } \{ - \beta , r _ { k } ^ { i } ( \theta ) \} } \end{array}$   
+6: while no stopping criterion has been met:   
+7: Shuffle $\{ \hat { \mathcal { X } } _ { \bar { j } } ^ { - } \} _ { \bar { j } } ^ { K }$ into $N$ mini-batches;   
+8: for $i = 1$ to $N$ :   
+9: $\begin{array} { r } { \mathbf { i f } \operatorname* { m i n } _ { k } [ r _ { 1 } ^ { i } ( \theta ) , \dots , r _ { k } ^ { i } ( \theta ) , \dots , r _ { K } ^ { i } ( \theta ) ] > - \beta \colon } \end{array}$   
+10: Set gradient $\nabla _ { \theta } L ^ { i } ( \theta )$ ;   
+11: Update $\theta$ by $\mathcal { A }$ with its current step size $\eta$ ;   
+12: else:   
+13: Set gradient $- \nabla _ { \boldsymbol { \theta } } \widetilde { L } ^ { i } ( \boldsymbol { \theta } )$ ;   
+14: Update $\theta$ by $\mathcal { A }$ with a discounted step size $\gamma \eta$ ;
+
+# 4.1 SETUP
+
+For MNIST and Fashion-MNIST, a linear-in-input model with a bias term and a MLP model $( d -$ $5 0 0 - 1 )$ was trained with softmax cross-entropy loss function. Weight decay of $1 e - 4$ for weight parameters and learning rate of $5 e - 5$ for Adam (Kingma & Ba, 2015) was used.
+
+For CIFAR-10, DenseNet (Huang et al., 2017) and Resnet-18 (He et al., 2016) with default parameter settings were trained. Weight decay of $5 e - 4$ and initial learning rate of $1 e - 2$ was used. For optimization, stochastic gradient descent was used with the momentum set to 0.9. Learning rate was halved every 30 epochs.
+
+We trained and compared 5 methods (Free (8), Max operator (12), Gradient ascent (Alg.1), PC (Ishida et al., 2017) and Forward (Yu et al., 2018)) with only complementarily labeled data. Note that the first three are the proposed methods. We complementarily labeled our benchmark datasets so that the assumption of (3) is satisfied. This is straightforward when the dataset has a uniform (ordinarily-labeled) class prior, because it reduces to just choosing a class randomly other than the true class. For Gradient ascent, we used $\beta = 0$ and $\gamma = 0$ for simplicity. We trained 300 epochs, where mini-batch was set to 100.
+
+# 4.2 RESULTS
+
+Instead of showing the test accuracy for a single chosen model based on validation, we show the accuracy for all 300 epochs on test data to demonstrate how the issues discussed in Section 3.2 appear and how different implementations Section 3.4 is effective. In Figure 2, we show the mean test accuracy and standard deviation for 4 trials for the three benchmark datasets, on test data evaluated with ordinary labels.
+
+First we compare our three proposed methods with each other. For linear models in MNIST and Fashion-MNIST, all proposed methods work similarly. However in the case of using a more flexible model (MLP model for MNIST/Fashion-MNIST, Densenet/Resnet for CIFAR-10), we can see that Free is the worst, Max operator is better and Gradient ascent is the best out of the proposed three methods at the end of all epochs $F r e e < M a x$ operator $<$ Gradient ascent). These results are consistent with the discussions of overfitting in Section 3.2 and the motivations for different implementations in Section 3.4.
+
+Next, we compare with baseline methods. For linear models, all methods have similar performance.   
+However for deep models, the superiority stands out for Gradient ascent for all datasets.
+
+![](images/24f13e5b2ca81db9ac3aad7836e191f1ab7625e4edac07a846fa1a3b3f80c16d.jpg)  
+Figure 2: Experimental results for various datasets and models. Dark colors show the mean accuracy of 4 trials and light colors show standard deviation.
+
+# 5 CONCLUSION
+
+We first proposed a general risk estimator for learning from complementary labels that does not require restrictions on the form of the loss function or the model. However, since the proposed method suffers from overfitting, we proposed a modified version to alleviate this issue in two ways and have better performance. At last, we conducted experiments to show our proposed method outperforms or is comparable to current state-of-the-art methods for various benchmark datasets and for both linear and deep models.
+
+# REFERENCES
+
+Han Bao, Gang Niu, and Masashi Sugiyama. Classification from pairwise similarity and unlabeled data. In ICML, 2018.
+
+Olivier Chapelle, Bernhard Schölkopf, and Alexander Zien (eds.). Semi-Supervised Learning. MIT Press, 2006.
+
+Marthinus Christoffel du Plessis, Gang Niu, and Masashi Sugiyama. Analysis of learning from positive and unlabeled data. In NIPS, 2014.
+
+Marthinus Christoffel du Plessis, Gang Niu, and Masashi Sugiyama. Convex formulation for learning from positive and unlabeled data. In ICML, 2015.
+
+Charles Elkan and Keith Noto. Learning classifiers from only positive and unlabeled data. In KDD, 2008.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q. Weinberger. Densely connected convolutional networks. In CVPR, 2017.
+
+Takashi Ishida, Gang Niu, Weihua Hu, and Masashi Sugiyama. Learning from complementary labels. In NIPS, 2017.
+
+Takashi Ishida, Gang Niu, and Masashi Sugiyama. Binary classification from positive-confidence data. In NIPS, 2018. To appear.
+
+Diederik P. Kingma and Jimmy L. Ba. Adam: A method for stochastic optimization. In ICLR, 2015.
+
+Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017.
+
+Ryuichi Kiryo, Gang Niu, Marthinus Christoffel du Plessis, and Masashi Sugiyama. Positiveunlabeled learning with non-negative risk estimator. In NIPS, 2017.
+
+Xingjun Ma, Yisen Wang, Michael E. Houle, Shuo Zhou, Sarah M. Erfani, Shu-Tao Xia, Sudanthi Wijewickrema, and James Bailey. Dimensionality-driven learning with noisy labels. In ICML, 2018.
+
+Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, Ken Nakae, and Shin Ishii. Distributional smoothing with virtual adversarial training. In ICLR, 2016.
+
+Vinod Nair and Geoffrey E. Hinton. Rectified linear units improve restricted boltzmann machines. In ICML, 2010.
+
+Nagarajan Natarajan, Inderjit S. Dhillon, Pradeep K. Ravikumar, and Ambuj Tewari. Learning with noisy labels. In NIPS, 2013.
+
+Avital Oliver, Augustus Odena, Colin Raffel, Ekin D. Cubuk, and Ian J. Goodfellow. Realistic evaluation of deep semi-supervised learning algorithms. In NIPS, 2018. To appear.
+
+Giorgio Patrini, Alessandro Rozza, Aditya Menon, Richard Nock, and Lizhen Qu. Making deep neural networks robust to label noise: A loss correction approach. In CVPR, 2017.
+
+Tomoya Sakai, Marthinus Christoffel du Plessis, Gang Niu, and Masashi Sugiyama. Semisupervised classification based on classification from positive and unlabeled data. In ICML, 2017.
+
+Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In NIPS, 2017.
+
+Xiyu Yu, Tongliang Liu, Mingming Gong, and Dacheng Tao. Learning with biased complementary labels. In ECCV, 2018.
+
+Tong Zhang. Statistical analysis of some multi-category large margin classification methods. Journal of Machine Learning Research, 5:1225–1251, 2004.
+
+# A PROOF OF THEOREM 1
+
+Proof. First of all,
+
+$$
+{ \begin{array} { r l } & { \mathbb { P } ( X , { \overline { { Y } } } = { \overline { { y } } } ) = { \frac { 1 } { K - 1 } } \sum _ { y \neq { \overline { { y } } } } \mathbb { P } ( X , Y = y ) } \\ & { \quad \quad = { \frac { 1 } { K - 1 } } { \Big ( } \sum _ { y = 1 } ^ { K } \mathbb { P } ( X , Y = y ) - \mathbb { P } ( X , Y = { \overline { { y } } } ) { \Big ) } } \\ & { \quad \quad = { \frac { 1 } { K - 1 } } { \big ( } \mathbb { P } ( X ) - \mathbb { P } ( X , Y = { \overline { { y } } } ) { \big ) } . } \end{array} }
+$$
+
+The first equality holds since the marginal distribution is equivalent for $\mathcal { D }$ and $\overline { { \mathcal { D } } }$ and we assume (3). Consequently,
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { P } ( \overline { { Y } } = \overline { { y } } | X = x ) = \frac { \mathbb { P } ( X = x , \overline { { Y } } = \overline { { y } } ) } { \mathbb { P } ( X = x ) } } \\ { \displaystyle = \frac { 1 } { K - 1 } \cdot \Big ( 1 - \frac { \mathbb { P } ( X , Y = \overline { { y } } ) } { \mathbb { P } ( X = x ) } \Big ) } \\ { \displaystyle = \frac { 1 } { K - 1 } \cdot \big ( 1 - \mathbb { P } ( Y = \overline { { y } } | X = x ) \big ) } \\ { \displaystyle = - \frac { 1 } { K - 1 } \mathbb { P } ( Y = \overline { { y } } | X = x ) + \frac { 1 } { K - 1 } . } \end{array}
+$$
+
+More simply, we have
+
+$$
+\pmb { \eta } ( x ) = - ( K - 1 ) \overline { { \pmb { \eta } } } ( x ) + \mathbf { 1 } .
+$$
+
+Finally, we transform the classification risk,
+
+$$
+\begin{array} { r l } { R ( g ; \ell ) = \mathbb { E } _ { ( X , Y ) \sim \overline { { D } } } [ \ell ( Y , g ( X ) ) ] } & { } \\ & { = \mathbb { E } _ { X \sim M } [ \eta ^ { \top } \ell ( g ( X ) ) ] } \\ & { = \mathbb { E } _ { X \sim M } \Big [ \big ( - ( K - 1 ) \overline { { \eta } } ^ { \top } + \mathbf { 1 } ^ { \top } \big ) \ell \big ( g ( X ) \big ) \Big ] } \\ & { = \mathbb { E } _ { X \sim M } \Big [ - ( K - 1 ) \overline { { \eta } } ^ { \top } \ell \big ( g ( X ) \big ) + \mathbf { 1 } ^ { \top } \ell \big ( g ( X ) \big ) \Big ] } \\ & { = \mathbb { E } _ { ( X , \overline { { Y } } ) \sim \overline { { D } } } \big [ - ( K - 1 ) \cdot \ell \big ( \overline { { Y } } , g ( X ) \big ) \big ] + \mathbf { 1 } ^ { \top } \mathbb { E } _ { X \sim M } \big [ \ell \big ( g ( X ) \big ) \big ] } \\ & { = \displaystyle \sum _ { k = 1 } ^ { K } \mathbb { E } _ { X \sim \overline { { P } } _ { k } } \Big [ \overline { { \pi } } _ { k } \cdot \Big ( - ( K - 1 ) \cdot \ell \big ( k , g ( X ) \big ) + \mathbf { 1 } ^ { \top } \ell \big ( g ( X ) \big ) \Big ) \Big ] } \\ & { = R ( g ; \overline { { \ell } } ) } \end{array}
+$$
+
+for the complementary loss,
+
+$$
+\overline { { \ell } } ( k , \pmb { g } ) : = - ( K - 1 ) \ell ( k , \pmb { g } ) + \mathbf { 1 } ^ { \top } \ell ( \pmb { g } ) ,
+$$
+
+which concludes the proof.
+
+# B DETAILS OF DATASETS USED IN SECTION 4
+
+In Table 2, we explain the details of the datasets used in Section 4. See http://yann.lecun.com/exdb/mnist/ for MNIST, https://github.com/zalandoresearch/fashion-mnist for Fashion-MNIST, and https://www.cs.toronto.edu/\~kriz/cifar.html for CIFAR-10.
+
+Table 2: Summary statistics of benchmark datasets.   
+
+<table><tr><td>Name</td><td>#Train</td><td>#Test</td><td>#Dim</td><td># Classes</td><td>Model</td></tr><tr><td>MNIST</td><td>60,000</td><td>10,000</td><td>784</td><td>10</td><td>Linear, MLP</td></tr><tr><td>Fashion MNIST</td><td>60.000</td><td>10,000</td><td>784</td><td>10</td><td>Linear,MLP</td></tr><tr><td>CIFAR-10</td><td>60,000</td><td>10,000</td><td>2,048</td><td>10</td><td>DenseNet, Resnet</td></tr></table>

parse/train/SJMnG2C9YX/SJMnG2C9YX_content_list.json

@@ -0,0 +1,1392 @@
+[
+    {
+        "type": "text",
+        "text": "COMPLEMENTARY-LABEL LEARNING FOR ARBITRARY LOSSES AND MODELS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            99,
+            648,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In contrast to the standard classification paradigm where the true (or possibly noisy) class is given to each training pattern, complementary-label learning only uses training patterns each equipped with a complementary label. This only specifies one of the classes that the pattern does not belong to. The seminal paper on complementary-label learning proposed an unbiased estimator of the classification risk that can be computed only from complementarily labeled data. However, it required a restrictive condition on the loss functions, making it impossible to use popular losses such as the softmax cross-entropy loss. Recently, another formulation with the softmax cross-entropy loss was proposed with consistency guarantee. However, this formulation does not explicitly involve a risk estimator. Thus model/hyper-parameter selection is not possible by cross-validation— we may need additional ordinarily labeled data for validation purposes, which is not available in the current setup. In this paper, we give a novel general framework of complementary-label learning, and derive an unbiased risk estimator for arbitrary losses and models. We further improve the risk estimator by non-negative correction and demonstrate its superiority through experiments. ",
+        "bbox": [
+            233,
+            263,
+            764,
+            486
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            510,
+            336,
+            526
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Modern classification methods usually require massive data with high-quality labels, but preparing such datasets is unrealistic in many practical domains. To mitigate the problem, many previous works have investigated ways to learn from weak supervision: semi-supervised learning (Chapelle et al., 2006; Miyato et al., 2016; Kipf & Welling, 2017; Sakai et al., 2017; Tarvainen & Valpola, 2017; Oliver et al., 2018), learning from noisily-labeled data (Natarajan et al., 2013; Patrini et al., 2017; Ma et al., 2018), learning from positive-unlabeled data (Elkan & Noto, 2008; du Plessis et al., 2014; 2015; Kiryo et al., 2017), learning from similar-unlabeled data (Bao et al., 2018), learning from positive-confidence data (Ishida et al., 2018), and others. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            652
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we consider learning from another type of weak but natural supervision called complementary-label learning (Ishida et al., 2017; Yu et al., 2018), where the label only specifies one of the classes that the pattern does not belong to. In contrast to the ordinary case where the true class is given to each pattern (which often needs to be chosen out of many candidate classes precisely), collecting these complementary labels is obviously much easier and less costly. A natural question is, however, is it possible to learn from such complementary labels (without any true labels)? ",
+        "bbox": [
+            174,
+            659,
+            825,
+            756
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The problem has previously been tackled by Ishida et al. (2017), showing that the classification risk can be recovered only from complementarily labeled data. They also gave consistency gaurantee in theoretical analysis. However, they required strong restrictions on the loss functions, allowing only one-versus-all and pairwise comparison multi-class loss functions (Zhang, 2004) with certain non-convex binary losses. This is a severe limitation when we use deep learning since the softmax cross-entropy loss is often used to boost the classification performance. ",
+        "bbox": [
+            174,
+            762,
+            823,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Later, Yu et al. (2018) proposed a different formulation for complementary labels by employing the forward loss correction technique (Patrini et al., 2017) to adjust the learning objective. Their proposed risk estimator is not necessarily unbiased but the minimizer is theoretically guaranteed to be consistent with the minimizer of the risk for ordinary labels (under an implicit assumption on the model for convergence analysis). ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/0e12f248bdd891be58d9e64c4c17e075d17735520309277423b06765a505fc47.jpg",
+        "table_caption": [
+            "Table 1: Comparison of two proposed complementary-label methods with previous works. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>loss assump. free</td><td>model assump. free</td><td>unbiased estimator</td><td>explicit risk correction</td></tr><tr><td>Ishida et al. (2017)</td><td>×</td><td>√</td><td>√</td><td>×</td></tr><tr><td>Yu et al. (2018)</td><td>×</td><td>×</td><td>×</td><td>×</td></tr><tr><td>Proposed (General formulation)</td><td></td><td>√</td><td>√</td><td></td></tr><tr><td>Proposed (Non-negative formulation)</td><td>√</td><td></td><td>×</td><td>×</td></tr></table>",
+        "bbox": [
+            173,
+            127,
+            830,
+            233
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "They also extended the problem setting to where complementary labels are chosen in an uneven (biased) way. This is a realistic problem setting because labelers are more likely to complementarily label a pattern when they feel it is not a certain class which they have more knowledge or experience about. ",
+        "bbox": [
+            174,
+            261,
+            825,
+            316
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we first derive an unbiased risk estimator with a general loss function, making any loss functions available for use: not only the softmax cross-entropy loss function but other convex/nonconvex loss functions can also be applied. We also do not have implicit assumptions on the classifier, allowing both linear and non-linear models. ",
+        "bbox": [
+            173,
+            323,
+            825,
+            380
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Yu et al. (2018) does not have an unbiased risk estimator, which means users will need clean data with true labels to calculate the error rate during the validation process. On the other hand, our proposed unbiased risk estimator can handle complementarily labeled validation data not only for our learning objective, but also for Yu et al. (2018). This is helpful since collecting clean data is usually much more expensive. ",
+        "bbox": [
+            174,
+            387,
+            825,
+            457
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, our proposed unbiased risk estimator has an issue that it is unbounded from below and suffers from the classification risk going to negative after learning, leading to overfitting. We further propose a non-negative correction to the original unbiased risk estimator to improve our estimator. We experimentally show that our proposed method is comparable to or better than previous methods (Ishida et al., 2017; Yu et al., 2018) in terms of classification accuracy. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            534
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 REVIEW OF PREVIOUS WORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            556,
+            457,
+            571
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we explain the notations and review the formulations of learning from ordinary labels, learning from complementary labels, and learning from both ordinary and complementary labels. ",
+        "bbox": [
+            173,
+            589,
+            823,
+            618
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning from ordinary labels Let $\\mathcal { X }$ be an instance space and $\\mathcal { D }$ be the joint distribution over $\\mathcal { X } \\times [ K ]$ for class label set $[ K ] : = \\{ 1 , 2 , \\dots , K \\}$ , with random variables $( { \\bar { X } } , Y ) \\sim { \\mathcal { D } }$ . The data at hand is sampled inThe joint distribution pendently and identically from the joint distributiocan be either decomposed into class-conditionals $\\{ ( x _ { i } , y _ { i } ) \\} _ { i = 1 } ^ { n } \\stackrel { \\mathrm { i . i . d . } } { \\sim } \\mathcal { D }$ $\\mathcal { D }$ $\\{ P _ { k } \\} _ { k = 1 } ^ { K }$ $\\{ \\pi _ { k } \\} _ { k = 1 } ^ { K }$ , where $P _ { k } : = \\mathbb { P } ( X | Y = k )$ and $\\pi _ { k } : = \\mathbb { P } ( Y = k )$ , or the marginal $M$ and class-probability function $\\eta : \\mathcal { X } \\ :  \\ : \\Delta _ { k }$ , where $M : = \\mathbb { P } ( X )$ and $\\pmb { \\eta } _ { k } ( x ) : = \\mathbb { P } ( Y = \\pmb { k } | X = x )$ . A loss is any $\\ell : [ K ] \\times \\mathbb { R } ^ { K } \\to \\mathbb { R } _ { + }$ and the decision function is any $g : \\mathcal { X } \\overset { } {  } \\mathbb { R } ^ { K }$ . The risk for the decision function $\\textbf {  { g } }$ with respect to loss $\\ell$ and implicit distribution $\\mathcal { D }$ is: ",
+        "bbox": [
+            173,
+            635,
+            825,
+            756
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b9934d81fe10507256f7e191c28bff9d8da73f3f61fbbbd0d7142f041fea99ec.jpg",
+        "text": "$$\nR ( g ; \\ell ) : = \\mathbb { E } _ { ( X , Y ) \\sim \\mathcal { D } } [ \\ell ( Y , \\pmb { g } ( X ) ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            763,
+            617,
+            782
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { E }$ denotes the expectation. Two useful equivalent expressions of classification risk (1) used in later sections are ",
+        "bbox": [
+            171,
+            790,
+            825,
+            819
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3e0a2dc742605b177742009f56521efb03572b736d79b24f8f4281b20147f78c.jpg",
+        "text": "$$\nR ( g ; \\ell ) : = \\mathbb { E } _ { X } [ \\eta ( x ) ^ { T } \\ell ( { \\pmb g } ( X ) ) ] = \\sum _ { k = 1 } ^ { K } \\pi _ { k } \\mathbb { E } _ { \\mathbb { P } _ { k } } \\Big [ \\ell ( k , { \\pmb g } ( X ) ) \\Big ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            825,
+            697,
+            869
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\ell : = [ \\ell ( 1 , \\pmb { g } ) , \\ell ( 2 , \\pmb { g } ) , \\dots , \\ell ( K , \\pmb { g } ) ] ^ { T }$ . The goal of classification is to learn the decision function that minimizes the risk. In the usual classification case with ordinarily labeled data at hand, approximating the risk empirically is straightforward: $\\begin{array} { r } { \\widehat { R } ( g ; \\ell ) : = \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\ell ( y _ { i } , g ( x _ { i } ) ) } \\end{array}$ . ",
+        "bbox": [
+            174,
+            877,
+            825,
+            926
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning from complementary labels Next we consider the problem of learning from complementary labels (Ishida et al., 2017). We observe patterns each equipped with a complementary label $\\{ ( x _ { i ^ { \\prime } } , \\stackrel { \\cdot } { y } _ { i ^ { \\prime } } ) \\} _ { i ^ { \\prime } = 1 } ^ { n ^ { \\prime } }$ sampled independently and identically from a different joint distribution $\\overline { { \\mathcal { D } } } \\neq \\mathcal { D }$ . We denote random variables as $( X , { \\overline { { Y } } } ) \\sim { \\overline { { \\mathcal { D } } } }$ . As before, we assume this distribution can be decomposed into either class-conditionals $\\{ \\overline { { P } } _ { k } \\} _ { k = 1 } ^ { K }$ and base rate $\\{ \\overline { { \\pi } } \\} _ { k = 1 } ^ { K }$ , or marginal $M$ and classprobability function $\\overline { { \\eta } } : \\mathcal { X } \\to \\Delta _ { K }$ , where ${ \\overline { { P } } } _ { k } : = \\mathbb { P } ( X | { \\overline { { Y } } } = k )$ , $\\overline { { \\pi } } _ { k } : = \\mathbb { P } ( \\overline { { Y } } = k )$ , $M : = \\mathbb { P } ( X )$ , $\\overline { { \\eta } } _ { k } ( x ) : = \\mathbb { P } ( \\overline { { Y } } = k | X = x )$ , $\\overline { { Y } }$ is the complementary label, and $\\Delta _ { K }$ is the conditional probability simplex for $K$ classes. Without any assumptions on $\\overline { { \\mathcal { D } } }$ , it is impossible to design a suitable learning procedure. The assumption for unbiased complementary learning used in Ishida et al. (2017) was ",
+        "bbox": [
+            173,
+            103,
+            825,
+            241
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/99dd43699ca8abaddb1ee2e3b840f40bd9b51d86e45184e53c63dd7069c124c1.jpg",
+        "text": "$$\n\\overline { { { \\eta } } } ( \\boldsymbol { x } ) = T \\eta ( \\boldsymbol { x } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            442,
+            250,
+            553,
+            268
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { T } \\in \\mathbb { R } ^ { K \\times K }$ is a matrix that takes 0 on diagonals and $\\frac { 1 } { K - 1 }$ on non-diagonals. Under this assumption, Ishida et al. (2017) proved that they can recover the classification risk (1) from an alternative formulation using only complementarily labeled data when he loss function satisfies certain conditions. More specifically, usable loss functions are pairwise comparison or one-versus-all multi-class loss functions (Zhang, 2004) each with binary loss function $\\ell ^ { \\bar { \\prime } } ( z ) : \\mathbb { R } \\to \\mathbb { R } _ { + }$ that satisfies $\\ell ^ { \\prime } ( z ) + \\ell ^ { \\prime } ( - z ) = 1$ , such as ramp loss $\\begin{array} { r } { \\ell _ { R } ^ { \\prime } ( z ) = \\frac { 1 } { 2 } \\operatorname* { m a x } \\left( 0 , \\operatorname* { m i n } ( 2 , 1 - z ) \\right) } \\end{array}$ or sigmoid loss ℓ′S (z ) = 11+ez . ",
+        "bbox": [
+            173,
+            286,
+            825,
+            393
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Having an unbiased risk estimator is also helpful for the validation process. Since we do not have ordinary labels in our validation set in the complementary-label learning setting, we cannot follow the usual validation procedure that uses zero-one error or accuracy. If we have an unbiased estimator of the original classification risk (which can be interpreted as zero-one error), we can use the empirical risk for (cross)-validated complementary data to select the best hyper-parameter or deploy early stopping. ",
+        "bbox": [
+            173,
+            398,
+            825,
+            483
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An extension of the above method was considered in Yu et al. (2018) by using a different assumption than the unbiased complementary learning of Ishida et al. (2017): there is some bias amongst the possible complementary labels that can be chosen, thus the non-diagonals of $_ { \\mathbf { T } }$ is not restricted to $\\frac { 1 } { K - 1 }$ . However, one will need to prepare a separate dataset with ordinary labels in order to estimate $_ { \\mathbf { T } }$ beforehand. ",
+        "bbox": [
+            174,
+            489,
+            825,
+            560
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unlike Ishida et al. (2017), Yu et al. (2018) did not directly provide a risk estimator, but they showed that the minimizer of their learning objective agrees with the minimizer of the original classification risk (1). Note that, in their formulation, the loss function is restricted to the softmax cross-entropy loss. Furthermore, the use of a highly non-linear model is supposed for consistency guarantee in their theoretical analysis. Since the learning objective of $\\mathrm { Y u }$ et al. (2018) does not correspond to the classification risk, one will need clean data with true labels to calculate the error rate during the validation process. On the other hand, our proposed risk estimator can cope with complementarily labeled validation data not only for our own learning objective, but can be used to select hyperparameters for others such as Yu et al. (2018). ",
+        "bbox": [
+            173,
+            566,
+            825,
+            693
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Learning from both ordinary and complementary labels In many practical situations, we may also have ordinarily labeled data in addition to complementarily labeled data. Ishida et al. (2017) touched on the idea of crowdsourcing for an application with both types of data. For example, we may choose one of the classes randomly by following the uniform distribution, with probability $\\frac { 1 } { K - 1 }$ for each class, and ask crowdworkers whether a pattern belongs to the chosen class or not. Then the pattern is treated as ordinarily labeled if the answer is yes; otherwise, the pattern is regarded as complementarily labeled. If the true label was $y$ for a pattern, we can naturally assume that the crowdworker will answer yes by $\\mathbb { P } ( Y = y | X = \\overset { \\cdot } { x } )$ and no by $1 - \\mathbb { P } ( Y = y | X \\mathbf { \\hat { = } } x )$ . This way, ordinarily labeled data can be regarded as samples from $\\mathcal { D }$ , and complementarily labeled data from $\\overline { { \\mathcal { D } } }$ , justifying the assumption of unbiased complementary learning (3). In Ishida et al. (2017), they considered a convex combination of the classification risks derived from ordinarily labeled data and complementarily labeled data: $\\alpha R ( g ; \\overline { { \\ell } } ) + ( 1 - \\alpha ) R ( g ; \\ell )$ , where $\\alpha \\in [ 0 , 1 ]$ is a hyper-parameter that interpolates between the two risks. The combined (also unbiased) risk estimator can utilize both kinds of data in order to obtain better classifiers, which was demonstrated to perform well in experiments. ",
+        "bbox": [
+            173,
+            713,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PROPOSED METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            372,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As discussed in the previous section, the method by Ishida et al. (2017) works well in practice, but it has restriction on the loss functions—the popular softmax cross-entropy loss is not allowed. On the other hand, the method by Yu et al. (2018) allows us to use the softmax cross-entropy loss, but it does not directly provide an estimator of the classification risk and thus model selection is problematic in practice. We first describe our general unbiased risk formulation in Section 3.1. Then we discuss how the estimator can be further improved in Section 3.2. Third, we propose a way for our risk estimator to avoid overfitting by a non-negative risk estimator in Section 3.3. Finally, we show practical implementation of our risk estimator with stochastic optimization methods in Section 3.4. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            244
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 GENERAL RISK FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            261,
+            426,
+            275
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "First, we describe our general unbiased risk formulation. We give the following theorem, which allows unbiased estimation of the classification risk from complementarily labeled samples: ",
+        "bbox": [
+            173,
+            286,
+            823,
+            315
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. For any ordinary distribution $\\mathcal { D }$ and complementary distribution $\\overline { { \\mathcal { D } } }$ related by (3) with decision function $\\textbf {  { g } }$ , and loss $\\ell$ , we have ",
+        "bbox": [
+            173,
+            319,
+            823,
+            348
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ffc6b652d750b48460edad25672884fe2012414499a8a79fd85f63b006d8eec4.jpg",
+        "text": "$$\nR ( \\pmb { g } ; \\ell ) = R ( \\pmb { g } ; \\bar { \\ell } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            437,
+            353,
+            562,
+            371
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "for the complementary loss ",
+        "bbox": [
+            173,
+            376,
+            354,
+            391
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3383e0de90353f84a64f8d495753a87ba4c25fedbde862302768ed2cbf0186f3.jpg",
+        "text": "$$\n\\overline { { \\ell } } ( \\pmb { g } ) : = \\Big ( - ( K - 1 ) \\pmb { I } _ { K } + \\frac { 1 } { K - 1 } \\pmb { 1 } \\pmb { 1 } ^ { \\top } \\Big ) \\cdot \\pmb { \\ell } ( \\pmb { g } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            396,
+            656,
+            428
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where 1 is a A. The key $K$ -dimensional column vector with 1 in each ela of the proof is to not rely on the condition e found in Appendix used in Ishida et al. $\\begin{array} { r } { \\sum _ { k = 1 } ^ { K } \\overline { { \\ell } } ( k , g ) = 1 } \\end{array}$ (2017), which is a condition inspired by the property of binary 0-1 loss $\\ell _ { 0 - 1 }$ , where if $z < 0$ and 0 otherwise. Note that such a technique was also used when designing unbiased risk estimators for learning from positive and unlabeled data in a binary classification setup (?), but was later shown to be unnecessary (du Plessis et al., 2015). ",
+        "bbox": [
+            173,
+            439,
+            825,
+            526
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "According to Theorem 1, we can derive an equivalent form, ",
+        "bbox": [
+            174,
+            532,
+            565,
+            546
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/53b4892812cc109c530f56ac7db47e711cf45ed2a54cbf6ade4decc00bdd4fba.jpg",
+        "text": "$$\n\\boldsymbol { \\overline { { \\ell } } } ( \\boldsymbol { k } , g ) = - ( K - 1 ) \\cdot \\boldsymbol { \\ell } ( \\boldsymbol { k } , g ) + \\sum _ { j = 1 } ^ { K } \\boldsymbol { \\ell } ( j , g ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            553,
+            642,
+            597
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Therefore, the classification risk can be written as ",
+        "bbox": [
+            174,
+            602,
+            501,
+            617
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e99a31f33a23ed2914c6da80c6a127cda493eef2497b49d8a456fda079599988.jpg",
+        "text": "$$\nR ( g ; \\ell ) = \\sum _ { k = 1 } ^ { K } \\overline { { { \\pi } } } _ { k } \\mathbb { E } _ { \\overline { { { P } } } _ { k } } \\Big [ - ( K - 1 ) \\cdot \\ell ( k , g ) + \\sum _ { j = 1 } ^ { K } \\ell ( j , g ) \\Big ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            621,
+            692,
+            666
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This expression of the classification risk allows us to naively approximate it in an unbiased fashion using complementarily labeled data as ",
+        "bbox": [
+            173,
+            671,
+            823,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/60ad28e409970055a32d28c4dff3581235b00de507a2be2eb877e7b407e3f77d.jpg",
+        "text": "$$\n\\widehat { R } ( g ; \\ell ) = \\sum _ { k = 1 } ^ { K } \\frac { \\widehat { \\pi } _ { k } } { n _ { k } } \\sum _ { i = 1 } ^ { n _ { k } } \\Big [ - ( K - 1 ) \\cdot \\ell \\big ( k , g ( \\pmb { x } _ { i } ) \\big ) + \\sum _ { j = 1 } ^ { K } \\ell ( j , g \\big ( \\pmb { x } _ { i } \\big ) \\big ) \\Big ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            705,
+            723,
+            750
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $n _ { k }$ is the number of samples complementarily labeled as the $k$ th class. It is worth noting that, in the above derivation, there are no constraints on the loss function and classifier. Thus, we can use any convex/non-convex loss and any linear/non-linear parametric/non-parametric model for complementary learning. ",
+        "bbox": [
+            176,
+            755,
+            825,
+            811
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 NECESSITY OF RISK CORRECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            447,
+            843
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The original expression of the classification risk (1) includes an expectation over non-negative loss $\\ell : [ K ] \\times \\mathbb { R } ^ { K } \\overset { \\cdot } {  } \\mathbb { R } _ { + }$ , so the risk and its empirical approximator are both lower-bounded by zero. On the other hand, the expression (7) derived above contains an negative element. Although (7) is still non-negative by definition, due to the negative term, its empirical estimator can go negative, leading to over-fitting. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/2c0b3b6c6c254c771a08350f3b0ac953c987ce742855b305c3cfabbf17657d04.jpg",
+        "image_caption": [
+            "Figure 1: The left and middle graphs shows the total risk (8) (in black color) and the risk decomposed into each ordinary class term (9) (in other colors) for training data with linear and MLP models, respectively. As an MLP model, a one-hidden-layer neural network with 500 units was used, with $R e L U$ (Nair & Hinton, 2010) as the activation function, Adam (Kingma & Ba, 2015) for optimization with learning rate $5 e - 5$ and weight decay of $1 e - 4$ . The right graph shows the corresponding test accuracy for both models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            77,
+            825,
+            218
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We elaborate on this issue with an illustrative numerical example. In the left graph of Figure 1, we show an example of training a linear model trained on the handwritten digits dataset $\\mathrm { \\bf M N I S T ^ { 1 } }$ , with complementary labels generated to satisfy (3). We used Adam (Kingma & Ba, 2015) for optimization with learning rate $5 e - 5$ , and weight decay of $1 e - 4$ with 300 epochs. The empirical classification risk (8) is shown in black. We can see that the empirical classification risk continues decreasing and can go below zero at around 100 epochs. The test accuracy on the right graph hits the peak also at around epoch 100 and then the accuracy gradually deteriorates. ",
+        "bbox": [
+            174,
+            320,
+            825,
+            417
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This issue stands out even more significantly when we use a flexible model. The middle graph shows the empirical classification risk for a multilayer perceptron (MLP) with one hidden layer (500 units), where ReLU (Nair & Hinton, 2010) was used as the activation function. The optimization setup was the same as the case of the linear model above. We can see the empirical risk decreasing much more quickly and going negative. Correspondingly, as the right graph shows, the test accuracy drops significantly after the empirical risk goes negative. ",
+        "bbox": [
+            173,
+            424,
+            825,
+            508
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In fact, a similar issue has already been conceivable in the original paper by Ishida et al. (2017): According to Theorem 1 in Ishida et al. (2017), the unbiased risk estimator includes subtraction of a positive constant term which increases with respect to the number of classes. This means that the learning objective of Ishida et al. (2017) has a (negative) lower bound. Our objective, however, is unbounded from below and thus can end up in even heavier overfitting. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            585
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 NON-NEGATIVE RISK ESTIMATOR ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            603,
+            446,
+            616
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As we saw in Section 3.2, our risk estimator can suffer from overfitting due to the non-negative issue. Here, we propose a correction to the risk estimator to overcome this problem. ",
+        "bbox": [
+            171,
+            628,
+            823,
+            656
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Each term in the risk with ordinary labels (right-hand side of (2)), which corresponds to each class, is non-negative. We can reformulate (7) in order to show the counterpart for each non-negative term in right-hand side of (2) for complementarily labeled data as ",
+        "bbox": [
+            174,
+            664,
+            823,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8e2fdaad09a4004bb7d048cdbbbbf4849ffb37fe583ce01e659f30885db70a1d.jpg",
+        "text": "$$\nR ( g ; \\ell ) = \\sum _ { k = 1 } ^ { K } \\overline { { \\pi } } _ { k } \\Big [ - ( K - 1 ) \\cdot \\mathbb { E } _ { \\overline { { P } } _ { k } } [ \\ell ( k , g ) ] + \\sum _ { j = 1 } ^ { K } \\mathbb { E } _ { \\overline { { P } } _ { j } } [ \\ell ( k , g ) ] \\Big ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            713,
+            717,
+            757
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "These counterparts (9) were originally non-negative when ordinary labels were used. In the left and middle graphs of Figure 1, we plot the decomposed risk with respect to each ordinary class (9) (shown in different colors). We can see that the decomposed risks for all classes become negative eventually. Based on this observation, our basic idea for correction is to enforce non-negativity for each ordinary class, with the expression based on complementary labels. More specifically, we propose a non-negative (nn) version by ",
+        "bbox": [
+            173,
+            763,
+            825,
+            848
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c2bd209cbf3ca0d17dfd000369c773eef65f56e7c636e4a0323c6d1bc2fc8a78.jpg",
+        "text": "$$\nR _ { \\mathrm { n n } } ( g ; \\ell ) = \\sum _ { k = 1 } ^ { K } \\operatorname* { m a x } \\Big \\{ 0 , \\overline { { \\pi } } _ { k } \\Big [ - ( K - 1 ) \\cdot \\mathbb { E } _ { \\overline { { P } } _ { k } } [ \\ell ( k , g ) ] + \\sum _ { j = 1 } ^ { K } \\mathbb { E } _ { \\overline { { P } } _ { j } } [ \\ell ( k , g ) ] \\Big ] \\Big \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            854,
+            758,
+            900
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This non-negative risk can be naively approximated by the sample average as ",
+        "bbox": [
+            173,
+            103,
+            679,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/42623d65d17e04da3b355dca2ca8edb5fbeebee3d76983a5728b5e6af6c541a3.jpg",
+        "text": "$$\n\\widehat { R } _ { \\mathrm { n n } } ( g ; \\ell ) = \\sum _ { k = 1 } ^ { K } \\operatorname* { m a x } \\Big \\{ 0 , \\pi \\Big [ - \\frac { K - 1 } { n _ { k } } \\sum _ { i = 1 } ^ { n _ { k } } \\ell ( k , g ( x _ { i } ) ) + \\sum _ { j = 1 } ^ { K } \\frac { 1 } { n _ { i ^ { \\prime } } } \\sum _ { i ^ { \\prime } = 1 } ^ { n _ { i ^ { \\prime } } } \\ell ( j , g ( x _ { i ^ { \\prime } } ) ) \\Big ] \\Big \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            205,
+            125,
+            764,
+            170
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Enforcing the reformulated risk to become non-negative was previously explored in Kiryo et al. (2017), in the context of binary classification from positive and unlabeled data. The positive class risk is already bounded below by zero in their case (because they have true positive labels), so there was a max operator only on the negative class risk. We basically follow their footsteps, but since our setting is a multi-class scenario and also differs by not having any true labels, we put a max operator on every $K$ class. ",
+        "bbox": [
+            173,
+            176,
+            825,
+            261
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4 IMPLEMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            279,
+            341,
+            292
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation with max operator We show practical implementation under stochastic optimization for our non-negative risk estimator. An unfortunate issue is that the minimization of (11) is not point-wise due to the max-operator, thus cannot be used directly for stochastic optimization methods with mini-batch. However, an upper bound of the risk can be minimized in parallel by using mini-batch as the following, ",
+        "bbox": [
+            174,
+            304,
+            825,
+            375
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d80dc19ae2b9255c8a9c85440c17732d4644dd64d167035aae1a301ab9bceac0.jpg",
+        "text": "$$\n\\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\sum _ { k = 1 } ^ { K } \\operatorname* { m a x } \\Big \\{ 0 , \\pi _ { k } \\Big [ - ( K - 1 ) \\widehat { \\mathbb { E } } _ { \\overline { { P } } _ { k } } [ \\ell ( k , g ) ; \\mathcal { X } _ { \\widehat { k } } ^ { i } ] + \\sum _ { j = 1 } ^ { K } \\widehat { \\mathbb { E } } _ { \\overline { { P } } _ { j } } [ \\ell ( k , g ) ; \\mathcal { X } _ { \\widehat { j } } ^ { i } ] \\Big ] \\Big \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            381,
+            759,
+            426
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\widehat { \\mathbb { E } }$ is the empirical version of the expectation and $\\mathcal { X } _ { \\overline { { j } } } ^ { i }$ denotes the samples complementarily labeled as the $j$ th class in the ith mini-batch. ",
+        "bbox": [
+            176,
+            435,
+            823,
+            468
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation with gradient ascent If the objective is negative for a certain mini-batch, the previous implementation based on the max operator will avoid the objective to further decrease. However, if the objective is already negative, that mini-batch has already started to overfit. Therefore, it would be preferable to increase itself to make this mini-batch less overfitted. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            540
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our idea is the following. We denote the risk that corresponds to the $k$ th ordinary class for the ith mini-batch as ",
+        "bbox": [
+            174,
+            546,
+            823,
+            575
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/693afb0e783bb9f5fdc2973acbd7d43bad8d7dc79df129c27bab809b4ce5261a.jpg",
+        "text": "$$\nr _ { k } ^ { i } ( \\theta ) = \\overline { { \\pi } } _ { k } \\big [ - ( K - 1 ) \\widehat { \\mathbb { E } } _ { \\overline { { P } } _ { k } } [ \\ell ( k , g ) ; \\mathcal { X } _ { \\overline { { k } } } ^ { i } ] + \\sum _ { j = 1 } ^ { K } \\widehat { \\mathbb { E } } _ { \\overline { { P } } _ { j } } [ \\ell ( k , g ) ; \\mathcal { X } _ { \\overline { { j } } } ^ { i } ] \\big ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            580,
+            717,
+            625
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "and the total risk as $\\begin{array} { r } { L ^ { i } ( \\theta ) = \\sum _ { k = 1 } ^ { K } r _ { k } ^ { i } ( \\theta ) } \\end{array}$ . When $\\mathrm { m i n } _ { k } \\{ r _ { k } ^ { i } ( \\theta ) \\} _ { k = 1 } ^ { K } \\geq - \\beta$ , we conduct gradient descent as usual with gradient $\\nabla _ { \\theta } L ^ { i } ( \\theta )$ . On the other hand, if $\\mathrm { m i n } _ { k } \\{ r _ { k } ^ { i } ( \\theta ) \\} _ { k = 1 } ^ { K } < - \\beta$ , we first squash the class-decomposed risks over $- \\beta$ to $- \\beta$ with a min operator, and then sum the results: $\\begin{array} { r } { \\tilde { L ^ { i } } ( \\theta ) = \\sum _ { k = 1 } ^ { K } \\operatorname* { m i n } \\{ - \\bar { \\beta } , r _ { k } ^ { i } ( \\theta ) \\} , } \\end{array}$ . ",
+        "bbox": [
+            173,
+            632,
+            825,
+            698
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Next we set the gradient in the opposite direction with $- \\nabla _ { \\boldsymbol { \\theta } } \\widetilde { L } ^ { i } ( \\boldsymbol { \\theta } )$ . Conceptually, we are going up the gradient $\\nabla _ { \\boldsymbol { \\theta } } \\widetilde { L } ^ { i } ( { \\boldsymbol { \\theta } } )$ for only the class-decomposed risks below $- \\beta$ , to avoid the class-decomposed risks that are already large to further increase. Note that $\\beta$ is a hyper-parameter that controls the tolerance of negativity. $\\beta = 0$ would mean there is zero tolerance, but in practice we can also have $- \\beta \\neq 0$ for a threshold that allows some negative ${ \\mathit { \\Omega } } ^ { \\prime } - \\beta < 0 { \\mathit { \\Gamma } }$ or positive $( - \\beta > 0 )$ ) amount. The procedure is shown in detail in Algorithm 1. ",
+        "bbox": [
+            173,
+            704,
+            825,
+            794
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            813,
+            326,
+            829
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we experimentally compare our three proposed methods (Algorithm 1, (8) and (12), with two baseline methods from Ishida et al. (2017) and Yu et al. (2018). Table 2 describes the summary statistics of the benchmark datasets used in this section. The implementation is based on Pytorch2 and our code will be available on http://anonymized for reproducing results. ",
+        "bbox": [
+            174,
+            844,
+            825,
+            901
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Input: complementarily labeled training data $\\{ \\mathcal { X } _ { \\overline { { k } } } \\} _ { \\overline { { k } } = 1 } ^ { K }$ , where ${ \\mathit { X } } _ { \\overline { { k } } }$ denotes the samples comple  \nmentarily labeled as class $\\overline { { k } }$ ;   \nOutput: model parameter $\\theta$ for $g ( { \\pmb x } ; { \\boldsymbol \\theta } )$   \n1: Let $\\mathcal { A }$ be an external SGD-like stochastic optimization algorithm such as Kingma & Ba (2015)   \n2: Denote $\\{ \\mathcal { X } _ { \\overline { { j } } } ^ { i } \\}$ as the $i$ -th mini-batch for complementary class $j$   \n3: Denote $\\begin{array} { r } { L ^ { i } ( \\theta ) = \\sum _ { k = 1 } ^ { K } r _ { k } ^ { i } ( \\theta ) } \\end{array}$   \n4: Denote $\\begin{array} { r } { r _ { k } ^ { i } ( \\theta ) = \\overline { { \\pi } } _ { k } \\widetilde { \\big [ } - ( K - 1 ) \\widehat { \\mathbb { E } } _ { \\overline { { P } } _ { k } } [ \\ell ( k , g ) ; \\mathcal { X } _ { \\overline { { k } } } ^ { i } ] + \\sum _ { j = 1 } ^ { K } \\widehat { \\mathbb { E } } _ { \\overline { { P } } _ { j } } [ \\ell ( k , g ) ; \\mathcal { X } _ { \\overline { { j } } } ^ { i } ] \\big ] } \\end{array}$   \n5: Denote $\\begin{array} { r } { \\widetilde L ^ { i } ( \\theta ) = \\sum _ { k = 1 } ^ { K } \\operatorname* { m i n } \\{ - \\beta , r _ { k } ^ { i } ( \\theta ) \\} } \\end{array}$   \n6: while no stopping criterion has been met:   \n7: Shuffle $\\{ \\hat { \\mathcal { X } } _ { \\bar { j } } ^ { - } \\} _ { \\bar { j } } ^ { K }$ into $N$ mini-batches;   \n8: for $i = 1$ to $N$ :   \n9: $\\begin{array} { r } { \\mathbf { i f } \\operatorname* { m i n } _ { k } [ r _ { 1 } ^ { i } ( \\theta ) , \\dots , r _ { k } ^ { i } ( \\theta ) , \\dots , r _ { K } ^ { i } ( \\theta ) ] > - \\beta \\colon } \\end{array}$   \n10: Set gradient $\\nabla _ { \\theta } L ^ { i } ( \\theta )$ ;   \n11: Update $\\theta$ by $\\mathcal { A }$ with its current step size $\\eta$ ;   \n12: else:   \n13: Set gradient $- \\nabla _ { \\boldsymbol { \\theta } } \\widetilde { L } ^ { i } ( \\boldsymbol { \\theta } )$ ;   \n14: Update $\\theta$ by $\\mathcal { A }$ with a discounted step size $\\gamma \\eta$ ; ",
+        "bbox": [
+            178,
+            118,
+            821,
+            395
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            425,
+            261,
+            439
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For MNIST and Fashion-MNIST, a linear-in-input model with a bias term and a MLP model $( d -$ $5 0 0 - 1 )$ was trained with softmax cross-entropy loss function. Weight decay of $1 e - 4$ for weight parameters and learning rate of $5 e - 5$ for Adam (Kingma & Ba, 2015) was used. ",
+        "bbox": [
+            176,
+            454,
+            823,
+            496
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For CIFAR-10, DenseNet (Huang et al., 2017) and Resnet-18 (He et al., 2016) with default parameter settings were trained. Weight decay of $5 e - 4$ and initial learning rate of $1 e - 2$ was used. For optimization, stochastic gradient descent was used with the momentum set to 0.9. Learning rate was halved every 30 epochs. ",
+        "bbox": [
+            174,
+            502,
+            825,
+            559
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We trained and compared 5 methods (Free (8), Max operator (12), Gradient ascent (Alg.1), PC (Ishida et al., 2017) and Forward (Yu et al., 2018)) with only complementarily labeled data. Note that the first three are the proposed methods. We complementarily labeled our benchmark datasets so that the assumption of (3) is satisfied. This is straightforward when the dataset has a uniform (ordinarily-labeled) class prior, because it reduces to just choosing a class randomly other than the true class. For Gradient ascent, we used $\\beta = 0$ and $\\gamma = 0$ for simplicity. We trained 300 epochs, where mini-batch was set to 100. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            664
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            685,
+            277,
+            700
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Instead of showing the test accuracy for a single chosen model based on validation, we show the accuracy for all 300 epochs on test data to demonstrate how the issues discussed in Section 3.2 appear and how different implementations Section 3.4 is effective. In Figure 2, we show the mean test accuracy and standard deviation for 4 trials for the three benchmark datasets, on test data evaluated with ordinary labels. ",
+        "bbox": [
+            174,
+            714,
+            825,
+            784
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "First we compare our three proposed methods with each other. For linear models in MNIST and Fashion-MNIST, all proposed methods work similarly. However in the case of using a more flexible model (MLP model for MNIST/Fashion-MNIST, Densenet/Resnet for CIFAR-10), we can see that Free is the worst, Max operator is better and Gradient ascent is the best out of the proposed three methods at the end of all epochs $F r e e < M a x$ operator $<$ Gradient ascent). These results are consistent with the discussions of overfitting in Section 3.2 and the motivations for different implementations in Section 3.4. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Next, we compare with baseline methods. For linear models, all methods have similar performance.   \nHowever for deep models, the superiority stands out for Gradient ascent for all datasets. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/24f13e5b2ca81db9ac3aad7836e191f1ab7625e4edac07a846fa1a3b3f80c16d.jpg",
+        "image_caption": [
+            "Figure 2: Experimental results for various datasets and models. Dark colors show the mean accuracy of 4 trials and light colors show standard deviation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            93,
+            810,
+            693
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            785,
+            318,
+            800
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We first proposed a general risk estimator for learning from complementary labels that does not require restrictions on the form of the loss function or the model. However, since the proposed method suffers from overfitting, we proposed a modified version to alleviate this issue in two ways and have better performance. At last, we conducted experiments to show our proposed method outperforms or is comparable to current state-of-the-art methods for various benchmark datasets and for both linear and deep models. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Han Bao, Gang Niu, and Masashi Sugiyama. Classification from pairwise similarity and unlabeled data. In ICML, 2018. ",
+        "bbox": [
+            173,
+            125,
+            823,
+            154
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Olivier Chapelle, Bernhard Schölkopf, and Alexander Zien (eds.). Semi-Supervised Learning. MIT Press, 2006. ",
+        "bbox": [
+            176,
+            161,
+            823,
+            190
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marthinus Christoffel du Plessis, Gang Niu, and Masashi Sugiyama. Analysis of learning from positive and unlabeled data. In NIPS, 2014. ",
+        "bbox": [
+            176,
+            198,
+            823,
+            227
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marthinus Christoffel du Plessis, Gang Niu, and Masashi Sugiyama. Convex formulation for learning from positive and unlabeled data. In ICML, 2015. ",
+        "bbox": [
+            173,
+            234,
+            821,
+            263
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Charles Elkan and Keith Noto. Learning classifiers from only positive and unlabeled data. In KDD, 2008. ",
+        "bbox": [
+            173,
+            271,
+            823,
+            301
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            308,
+            821,
+            337
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q. Weinberger. Densely connected convolutional networks. In CVPR, 2017. ",
+        "bbox": [
+            174,
+            343,
+            821,
+            373
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Takashi Ishida, Gang Niu, Weihua Hu, and Masashi Sugiyama. Learning from complementary labels. In NIPS, 2017. ",
+        "bbox": [
+            176,
+            381,
+            823,
+            410
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Takashi Ishida, Gang Niu, and Masashi Sugiyama. Binary classification from positive-confidence data. In NIPS, 2018. To appear. ",
+        "bbox": [
+            174,
+            416,
+            823,
+            446
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy L. Ba. Adam: A method for stochastic optimization. In ICLR, 2015. ",
+        "bbox": [
+            173,
+            454,
+            823,
+            470
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            477,
+            821,
+            506
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ryuichi Kiryo, Gang Niu, Marthinus Christoffel du Plessis, and Masashi Sugiyama. Positiveunlabeled learning with non-negative risk estimator. In NIPS, 2017. ",
+        "bbox": [
+            173,
+            512,
+            821,
+            542
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xingjun Ma, Yisen Wang, Michael E. Houle, Shuo Zhou, Sarah M. Erfani, Shu-Tao Xia, Sudanthi Wijewickrema, and James Bailey. Dimensionality-driven learning with noisy labels. In ICML, 2018. ",
+        "bbox": [
+            174,
+            549,
+            823,
+            592
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, Ken Nakae, and Shin Ishii. Distributional smoothing with virtual adversarial training. In ICLR, 2016. ",
+        "bbox": [
+            173,
+            599,
+            823,
+            630
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Vinod Nair and Geoffrey E. Hinton. Rectified linear units improve restricted boltzmann machines. In ICML, 2010. ",
+        "bbox": [
+            174,
+            636,
+            821,
+            665
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nagarajan Natarajan, Inderjit S. Dhillon, Pradeep K. Ravikumar, and Ambuj Tewari. Learning with noisy labels. In NIPS, 2013. ",
+        "bbox": [
+            173,
+            672,
+            823,
+            702
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Avital Oliver, Augustus Odena, Colin Raffel, Ekin D. Cubuk, and Ian J. Goodfellow. Realistic evaluation of deep semi-supervised learning algorithms. In NIPS, 2018. To appear. ",
+        "bbox": [
+            173,
+            709,
+            821,
+            739
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Giorgio Patrini, Alessandro Rozza, Aditya Menon, Richard Nock, and Lizhen Qu. Making deep neural networks robust to label noise: A loss correction approach. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            746,
+            821,
+            775
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tomoya Sakai, Marthinus Christoffel du Plessis, Gang Niu, and Masashi Sugiyama. Semisupervised classification based on classification from positive and unlabeled data. In ICML, 2017. ",
+        "bbox": [
+            174,
+            782,
+            821,
+            813
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In NIPS, 2017. ",
+        "bbox": [
+            173,
+            819,
+            821,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xiyu Yu, Tongliang Liu, Mingming Gong, and Dacheng Tao. Learning with biased complementary labels. In ECCV, 2018. ",
+        "bbox": [
+            173,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tong Zhang. Statistical analysis of some multi-category large margin classification methods. Journal of Machine Learning Research, 5:1225–1251, 2004. ",
+        "bbox": [
+            173,
+            892,
+            823,
+            921
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A PROOF OF THEOREM 1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            398,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Proof. First of all, ",
+        "bbox": [
+            173,
+            133,
+            297,
+            148
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dbe5ceaf84aaefbe83ee54896f46936a04500135e6c49dfa82b27e2a77751eff.jpg",
+        "text": "$$\n{ \\begin{array} { r l } & { \\mathbb { P } ( X , { \\overline { { Y } } } = { \\overline { { y } } } ) = { \\frac { 1 } { K - 1 } } \\sum _ { y \\neq { \\overline { { y } } } } \\mathbb { P } ( X , Y = y ) } \\\\ & { \\quad \\quad = { \\frac { 1 } { K - 1 } } { \\Big ( } \\sum _ { y = 1 } ^ { K } \\mathbb { P } ( X , Y = y ) - \\mathbb { P } ( X , Y = { \\overline { { y } } } ) { \\Big ) } } \\\\ & { \\quad \\quad = { \\frac { 1 } { K - 1 } } { \\big ( } \\mathbb { P } ( X ) - \\mathbb { P } ( X , Y = { \\overline { { y } } } ) { \\big ) } . } \\end{array} }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            155,
+            699,
+            272
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The first equality holds since the marginal distribution is equivalent for $\\mathcal { D }$ and $\\overline { { \\mathcal { D } } }$ and we assume (3). Consequently, ",
+        "bbox": [
+            171,
+            279,
+            821,
+            309
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ac2b17b18d52e219ae52032094fa0cd6a32ea2f288e703cf8a330668ce04928f.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\mathbb { P } ( \\overline { { Y } } = \\overline { { y } } | X = x ) = \\frac { \\mathbb { P } ( X = x , \\overline { { Y } } = \\overline { { y } } ) } { \\mathbb { P } ( X = x ) } } \\\\ { \\displaystyle = \\frac { 1 } { K - 1 } \\cdot \\Big ( 1 - \\frac { \\mathbb { P } ( X , Y = \\overline { { y } } ) } { \\mathbb { P } ( X = x ) } \\Big ) } \\\\ { \\displaystyle = \\frac { 1 } { K - 1 } \\cdot \\big ( 1 - \\mathbb { P } ( Y = \\overline { { y } } | X = x ) \\big ) } \\\\ { \\displaystyle = - \\frac { 1 } { K - 1 } \\mathbb { P } ( Y = \\overline { { y } } | X = x ) + \\frac { 1 } { K - 1 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            313,
+            694,
+            450
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "More simply, we have ",
+        "bbox": [
+            173,
+            453,
+            320,
+            468
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3e8f0dc4a8f18f47a1a584612707c3ed3a5b8353b78510bc523196e9a66a8d70.jpg",
+        "text": "$$\n\\pmb { \\eta } ( x ) = - ( K - 1 ) \\overline { { \\pmb { \\eta } } } ( x ) + \\mathbf { 1 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            474,
+            596,
+            492
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Finally, we transform the classification risk, ",
+        "bbox": [
+            173,
+            497,
+            464,
+            512
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8baf7b4b31866d67a54bb4d85b2e9ef7cf1fab84b7d4f197384c6bf0172dd5bd.jpg",
+        "text": "$$\n\\begin{array} { r l } { R ( g ; \\ell ) = \\mathbb { E } _ { ( X , Y ) \\sim \\overline { { D } } } [ \\ell ( Y , g ( X ) ) ] } & { } \\\\ & { = \\mathbb { E } _ { X \\sim M } [ \\eta ^ { \\top } \\ell ( g ( X ) ) ] } \\\\ & { = \\mathbb { E } _ { X \\sim M } \\Big [ \\big ( - ( K - 1 ) \\overline { { \\eta } } ^ { \\top } + \\mathbf { 1 } ^ { \\top } \\big ) \\ell \\big ( g ( X ) \\big ) \\Big ] } \\\\ & { = \\mathbb { E } _ { X \\sim M } \\Big [ - ( K - 1 ) \\overline { { \\eta } } ^ { \\top } \\ell \\big ( g ( X ) \\big ) + \\mathbf { 1 } ^ { \\top } \\ell \\big ( g ( X ) \\big ) \\Big ] } \\\\ & { = \\mathbb { E } _ { ( X , \\overline { { Y } } ) \\sim \\overline { { D } } } \\big [ - ( K - 1 ) \\cdot \\ell \\big ( \\overline { { Y } } , g ( X ) \\big ) \\big ] + \\mathbf { 1 } ^ { \\top } \\mathbb { E } _ { X \\sim M } \\big [ \\ell \\big ( g ( X ) \\big ) \\big ] } \\\\ & { = \\displaystyle \\sum _ { k = 1 } ^ { K } \\mathbb { E } _ { X \\sim \\overline { { P } } _ { k } } \\Big [ \\overline { { \\pi } } _ { k } \\cdot \\Big ( - ( K - 1 ) \\cdot \\ell \\big ( k , g ( X ) \\big ) + \\mathbf { 1 } ^ { \\top } \\ell \\big ( g ( X ) \\big ) \\Big ) \\Big ] } \\\\ & { = R ( g ; \\overline { { \\ell } } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            517,
+            738,
+            689
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "for the complementary loss, ",
+        "bbox": [
+            173,
+            694,
+            357,
+            708
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/83cc4a90c01087af8e4d474806047245108f860d7cdf367488f0e9baf69de027.jpg",
+        "text": "$$\n\\overline { { \\ell } } ( k , \\pmb { g } ) : = - ( K - 1 ) \\ell ( k , \\pmb { g } ) + \\mathbf { 1 } ^ { \\top } \\ell ( \\pmb { g } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            714,
+            629,
+            733
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "which concludes the proof. ",
+        "bbox": [
+            174,
+            741,
+            352,
+            755
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "B DETAILS OF DATASETS USED IN SECTION 4 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            773,
+            566,
+            791
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In Table 2, we explain the details of the datasets used in Section 4. See http://yann.lecun.com/exdb/mnist/ for MNIST, https://github.com/zalandoresearch/fashion-mnist for Fashion-MNIST, and https://www.cs.toronto.edu/\\~kriz/cifar.html for CIFAR-10. ",
+        "bbox": [
+            173,
+            806,
+            825,
+            863
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/f24640f736a3e5cfa8c27febc3467670fbc4ab5a1a9ae15529cb3570ed41ce44.jpg",
+        "table_caption": [
+            "Table 2: Summary statistics of benchmark datasets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Name</td><td>#Train</td><td>#Test</td><td>#Dim</td><td># Classes</td><td>Model</td></tr><tr><td>MNIST</td><td>60,000</td><td>10,000</td><td>784</td><td>10</td><td>Linear, MLP</td></tr><tr><td>Fashion MNIST</td><td>60.000</td><td>10,000</td><td>784</td><td>10</td><td>Linear,MLP</td></tr><tr><td>CIFAR-10</td><td>60,000</td><td>10,000</td><td>2,048</td><td>10</td><td>DenseNet, Resnet</td></tr></table>",
+        "bbox": [
+            250,
+            483,
+            745,
+            561
+        ],
+        "page_idx": 10
+    }
+]

parse/train/rYhBGWYm6AU/rYhBGWYm6AU.md

@@ -0,0 +1,223 @@
+# Intriguing Properties of Contrastive Losses
+
+Ting Chen Google Research iamtingchen@google.com
+
+Calvin Luo Google Research calvinluo@google.com
+
+Lala Li Google Research lala@google.com
+
+# Abstract
+
+We study three intriguing properties of contrastive learning. First, we generalize the standard contrastive loss to a broader family of losses, and we find that various instantiations of the generalized loss perform similarly under the presence of a multi-layer non-linear projection head. Second, we study if instance-based contrastive learning (with a global image representation) can learn well on images with multiple objects present. We find that meaningful hierarchical local features can be learned despite the fact that these objectives operate on global instancelevel features. Finally, we study the phenomenon of feature suppression among competing features shared across augmented views, such as “color distribution” vs “object class”. We construct datasets with explicit and controllable competing features and show that, for contrastive learning, a few bits of easy-to-learn shared features can suppress, and even fully prevent, the learning of other sets of competing features. In scenarios where there are multiple objects in an image, the dominant object would suppress the learning of smaller objects. Existing contrastive learning methods critically rely on data augmentation to favor certain sets of features over others, and could suffer from learning saturation for scenarios where existing augmentations cannot fully address the feature suppression. This poses open challenges to existing contrastive learning techniques 1.
+
+# 1 Introduction
+
+Contrastive learning [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] has recently achieved great successes in learning visual representations without supervision. As shown in [13, 14], contrastive learning can learn representations that rival supervised learning, and significantly improve the state-of-the-art in semi-supervised learning on ImageNet. One successful use case of contrastive loss for self-supervised learning is to make augmented views of the same example agree [1, 2, 13]. A widely used contrastive loss to encourage agreement is based on cross entropy [15, 3, 4, 13]. Given an augmented view of an example, the contrastive prediction task aims to classify a set of candidates into the positive example (i.e. the other augmented view of the same example) and negative ones via the cross entropy loss.
+
+In this work, to understand the effectiveness and limitation of existing contrastive learning methods, we study three intriguing aspects. First, we propose a generalization of the standard contrastive loss, and systematically study their performance differences. Second, we study if the instance-based contrastive learning, for which the contrastive loss operates on global representation of an input image, can learn well on images with multiple objects present, and whether or not it leads to meaningful local features. Finally, we systematically study the feature suppression phenomenon in contrastive learning. The suppression effect occurs among competing features shared across augmented views. For example, with random cropping as the augmentation, “color distribution” and “object class” are often competing features as they are likely shared between two augmented views. The suppression effect among competing features can significantly degenerate the representation quality, or even completely disable the learning of certain features, as shown in our experiments. Existing methods critically rely on hand-crafted data augmentation to favor certain sets of competing features than others.
+
+Our main findings and contributions are summarized below.
+
+• We propose a generalized contrastive loss, and show that differences between contrastive losses are small with a deep projection head.   
+• We show that the instance-based objective widely used in existing contrastive learning methods can learn on images with multiple objects, and also learn meaningful local features despite operating on global image representation.   
+• We construct three datasets with explicit and controllable competing features to systematically study the feature suppression effect in contrastive learning.   
+• We show that a few bits of easy-to-learn shared features can suppress, and even fully prevent, the learning of other sets of competing features. In scenarios where there are multiple objects in an image, the dominant object would suppress the learning of smaller objects. This poses open challenges to existing contrastive learning.
+
+# 2 Generalized contrastive loss and differences among its instantiations
+
+The common contrastive loss used in most recent work is based on cross entropy [15, 3, 4]. Following the notation in [13], the contrastive loss can be defined between two augmented views $( i , j )$ of the same example for a mini-batch of size of $n$ , and can be written as the following.
+
+$$
+\mathcal { L } ^ { \mathrm { N T - X e n t } } = - \frac { 1 } { n } \sum _ { i , j \in \mathcal { M B } } \log \frac { \exp ( \sin ( z _ { i } , z _ { j } ) / \tau ) } { \sum _ { k = 1 } ^ { 2 n } \mathbb { 1 } _ { [ k \neq i ] } \exp ( \sin ( z _ { i } , z _ { k } ) / \tau ) }
+$$
+
+where $z _ { i } , z _ { j }$ are hidden representations of two augmented views of the same example; $\sin ( { \boldsymbol { \mathbf { u } } } , { \boldsymbol { \mathbf { v } } } ) =$ $\pmb { u } ^ { T } \pmb { v } / ( \lVert \pmb { u } \rVert \lVert \pmb { v } \rVert )$ is the cosine similarity between two vectors; $\tau$ is a temperature scalar and $\mathcal { M } \mathcal { B }$ is a randomly sampled mini-batch consisting of augmented pairs of images. In [13], a MLP projection head is introduced between intermediate layer $^ { h }$ (e.g. output of ResNet encoder) and final output $_ { z }$ . It is shown that the projection head is very beneficial and $^ { h }$ is a much better feature representation than $_ { z }$ .
+
+In this work, we generalize the standard contrastive loss to the following form.
+
+$$
+\boxed { \mathcal { L } _ { \mathrm { g e n e r a l i z e d c o n t r a s t i v e } } = \mathcal { L } _ { \mathrm { a l i g n m e n t } } + \lambda \mathcal { L } _ { \mathrm { d i s t r i b u t i o n } } }
+$$
+
+Both terms are defined on hidden representations. $\mathcal { L } _ { \mathrm { a l i g n m e n t } }$ encourages representations of augmented views to be consistent, while ${ \mathcal { L } } _ { \mathrm { d i s t r i b u t i o n } }$ encourages representations (or a random subset of them) to match a prior distribution (of high entropy). It is not difficult to see that the standard contrastive loss in Eq. 1 is a special case as it can be re-written as follows (scaled by a constant $\tau$ ).
+
+$$
+\tau \mathcal { L } ^ { \mathrm { N T - X e n t } } = \underbrace { - \frac { 1 } { n } \sum _ { i , j } \sin ( z _ { i } , z _ { j } ) } _ { \mathcal { L } _ { \mathrm { a l i g n m e n t } } } + \underbrace { \frac { \tau } { n } \sum _ { i } \log \sum _ { k = 1 } ^ { 2 n } \mathbb { 1 } _ { [ k \neq i ] } \exp ( \sin ( z _ { i } , z _ { k } ) / \tau ) } _ { \mathcal { L } _ { \mathrm { d i s t r i b u t i o n } } }
+$$
+
+This form of factorization in Eq. 3 has been proposed in [16], where the second LogSumExp term is referred to as uniformity since it encourages representation to uniformly distributed in the hypersphere. Different from [16], here we generalize the hypersphere uniform distribution and study a wider set of prior distributions for their effectiveness in learning representations.
+
+SWD for supporting diverse prior distributions. One issue of using more diverse set of priors is we cannot rely on LogSumExp for matching the distribution. To this end, we resort to the theory of optimal transport, via Sliced Wasserstein Distance (SWD) [17, 18, 19]. For two sets of equalsized samples from two 1-D distributions, the optimal transport can be obtained by computing two permutations that order the values of both sets of samples respectively. The 1-D Wasserstein distance can then be computed with $\ell _ { 2 }$ distance between the ordered values. For n-D distributions, we first project the samples to $n$ randomly-generated orthogonal 1-D subspaces, and then compute the sum of 1-D Wasserstein distance across all 1-D subspaces. By adjusting the network weights to minimize the SWD, we are able to reduce the mismatch between the distribution of hidden vectors and a known prior distribution. The detailed algorithm can be found in Algorithm 1. With SWD loss, we are able to use a wider set of priors, and Table 1 summarizes instantiations of the generalized contrastive loss with different prior distributions and distribution matching loss.
+
+Algorithm 1 Sliced Wasserstein Distance (SWD) loss.   
+
+<table><tr><td>input: activation vectors H ∈ Rb×d, ,a prior distribution (e.g. Gaussian) sampler S draw prior vectors P ∈ Rb×d using S</td></tr><tr><td></td></tr><tr><td>generate random orthogonal matrix W ∈ Rd×d&#x27;</td></tr><tr><td>make projections: H-= HW; P⊥ = PW</td></tr><tr><td>initializeSWDlossl=0</td></tr><tr><td>forj∈{1,2,.,d&#x27;} do l =l+ |lsort(H:j)-sort(P:j)|l²</td></tr><tr><td></td></tr><tr><td>end for return l/(dd&#x27;)</td></tr></table>
+
+Table 1: Instantiations of the generalized contrastive loss, i.e. $\mathcal { L } _ { \mathrm { a l i g n m e n t } } + \lambda \mathcal { L } _ { \mathrm { d i s t r i b u t i o n } }$ , that we use in this work. $\tilde { z }$ denotes $\ell _ { 2 }$ -normalized $z \in \mathbb { R } ^ { d }$ , and is only used for uniform hypersphere prior.   
+
+<table><tr><td>Laign</td><td>Prior distribution</td><td>Ldistribution</td></tr><tr><td>nd∑i, |lzi - zj|l²Uniform hypersphere</td><td></td><td>e∑log∑exp(Tzj/T）</td></tr><tr><td>nd∑ij |lz- zjll2Uniform hypersphere</td><td></td><td>SWD(Z, zprior)</td></tr><tr><td>d∑ij|lz-zjll²Uniform hypercube</td><td></td><td>SWD(Z, Zprior)</td></tr><tr><td>nd∑i,j |lzi - zjll2Normal distribution</td><td></td><td>SWD(Z, Zprior)</td></tr></table>
+
+Connection with mutual information. The connection between the standard contrastive loss and mutual information has been shown before [3, 20], where the contrastive loss (a.k.a. InfoNCE loss [3]) is shown to be a lower bound of the mutual information. To connect the generalized contrastive loss to mutual information, we start by the definition of mutual information between two latent variables $U , V$ , which is $I ( U ; V ) = H ( U ) - H ( U | V )$ . Comparing this factorization of mutual information with generalized contrastive loss, it is not difficult to see that: 1) the alignment term $\mathcal { L } _ { \mathrm { a l i g n m e n t } }$ is directly related to $H ( U | V )$ which aims to reduce uncertainty of the other views given one view of the example; and 2) the distribution matching term ${ \mathcal { L } } _ { \mathrm { d i s t r i b u t i o n } }$ can be considered as a proxy to $H ( u )$ for maximizing the entropy in the representation. It is perhaps worth noting that different from mutual information, the generalized contrastive loss (Eq. 2) allows a tunable weight $( \lambda )$ between the alignment and distribution matching term. The weighting scalar $\lambda$ is (inversely) related to the temperature $\tau$ (details in Appendix A.2).
+
+Comparing different instantiations of generalized contrastive loss. Here we ask: Is it essential to use a uniform hypersphere prior for the effectiveness of contrastive loss? How much difference does it make when distinct generalized contrastive losses are used? To answer this question, we conduct experiments following SimCLR settings [13, 14], and use the linear evaluation protocol. Detailed experimental setup can be found in Appendix A.1.
+
+Figure 1 shows linear evaluation results of models trained with different losses under different training epochs. On CIFAR-10, we see little difference in terms of linear evaluation for variants of the generalized contrastive losses, especially when trained longer than 200 epochs. As for ImageNet, there are some discrepancies between different losses, but they disappear when a deeper 3-layer non-linear projection head is used.
+
+![](images/b2443f8eabb0e0479457a5400ec51cc75e840fb6d83df72f3695d1b7938e34df.jpg)  
+Figure 1: Linear evaluation accuracy of ResNet-50 trained with different losses on CIFAR-10 and ImageNet datasets. Numbers of projection head layers are in parentheses. Differences between variants of generalized contrastive loss are small with a deep projection head. Decoupled NT-Xent loss is introduced in A.2. Numerical results can be found in Appendix A.3.
+
+Furthermore, we find that deep projection head not only reduces the differences among different generalized contrastive losses, but has a similar effect for batch size. With proper learning rate scaling across batch sizes (e.g. square root scaling with LARS optimizer [21]), the impact of batch size on representation quality is small. Table 2 demonstrate this phenomenon for the standard contrastive loss, and more results on other losses can be found in Appendix A.3.
+
+Table 2: Linear eval accuracy of ResNet-50 on ImageNet.   
+
+<table><tr><td rowspan="2">Projection head</td><td rowspan="2">Batch size</td><td colspan="4">Epoch</td></tr><tr><td>100</td><td>200</td><td>400</td><td>800</td></tr><tr><td rowspan="3">2 layers</td><td>512</td><td>65.4</td><td>67.3</td><td>68.7</td><td>69.3</td></tr><tr><td>1024</td><td>65.6</td><td>67.6</td><td>68.8</td><td>69.8</td></tr><tr><td>2048</td><td>65.3</td><td>67.6</td><td>69.0</td><td>70.1</td></tr><tr><td rowspan="3">3 layers</td><td>512</td><td>66.6</td><td>68.4</td><td>70.0</td><td>71.0</td></tr><tr><td>1024</td><td>66.8</td><td>68.9</td><td>70.1</td><td>70.9</td></tr><tr><td>2048</td><td>66.8</td><td>69.1</td><td>70.4</td><td>71.3</td></tr><tr><td rowspan="3">4 layers</td><td>512</td><td>66.8</td><td>68.8</td><td>70.0</td><td>70.7</td></tr><tr><td>1024</td><td>67.0</td><td>69.0</td><td>70.4</td><td>70.9</td></tr><tr><td>2048</td><td>67.0</td><td>69.3</td><td>70.4</td><td>71.3</td></tr></table>
+
+# 3 Instance-based objective can learn on images with multiple objects and learn good local features
+
+Most existing contrastive learning methods [13, 10, 22, 4] define their objectives at the instance level where each image is encoded into a single vector representation (e.g. representations of two random crops of the same image instance are treated as a positive pair). In other words, the objective operates on a global representation of its input rather than on some local regions (of its input). We pose two questions regarding instance-based global objective: 1) when there is only a single (dominant) object in the image, the objective seems reasonable as it encourages the model to learn features relevant to object class, but when there are multiple objects present in the image, can instance-based objective still learn well? 2) Since the instance-based objective uses a global summary of its input, can it still learn good local features (e.g. parts of an object, or multiple objects in the same scheme)? To answer these questions, we use SimCLR as representative for the instance-based objective.
+
+# 3.1 SimCLR can learn on images with multiple objects
+
+Commonly used self-supervised learning datasets, such as MNIST, CIFAR-10, ImageNet, are object centered, i.e. the image is mainly occupied by a single (dominant) object. To experiment with multiple objects in a controllable setting, we propose a new dataset setting by composing multiple digits as follows.
+
+MultiDigits dataset. We place MNIST digits ( $2 8 \times 2 8$ size) on a shared canvas $1 1 2 \times 1 1 2$ size). We vary the number of digits placed on the canvas. One factor that could interfere with learning of multiple digits is overlapping digits, therefore we use two placement strategies: random vs in-grid (Figure 2). Random placement of digits incurs no constraint on where digits can be placed on the canvas, whereas in-grid placement puts each digit in one of the $4 \times 4$ grid cells the canvas is divided into, and no two digits can fall in the same cell. In-grid placement ensures no overlapping of digits.
+
+![](images/c71d419367e52d12da14816741144d4a892cd0560eb7e00b6d37305ccc59ec1e.jpg)  
+Figure 2: MultiDigit dataset. More digits lead to more overlapping in random placement.
+
+We first pretrain a ResNet-18 with SimCLR or supervised learning with the same augmentation policy (random cropping and resize) on MultiDigits dataset. To access the representation quality, we then train linear classifiers for images with a single digit of size $2 8 \times 2 8$ on the canvas. Similarly during evaluation, we place only one digit of size $2 8 \times 2 8$ on the canvas.
+
+As shown in Table 3, representations learned using supervised loss maintains its quality when up to 8 digits are placed in the image. After that the representation becomes worse as the canvas gets more crowded. Notably, representations learned using SimCLR display a similar phenomenon. Regardless of placement strategy, top-1 accuracy stays at the same level up to 8 digits, demonstrating that SimCLR can learn from images with multiple objects. In addition, the increased performance gap between the two placement strategies with increased number of digits shows that object overlapping makes it harder for contrastive losses to learn from multiple objects.
+
+Table 3: Top-1 linear evaluation accuracy $( \% )$ for pretrained ResNet-18 on the MultiDigits dataset. We vary the number of digits placed on the canvas during training from 1 to 16. During evaluation only 1 digit is present. As a baseline, a network with random weights gives $18 \%$ top-1 accuracy.   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">Placing of digits</td><td colspan="6">Number of digits (size 28 × 28)</td></tr><tr><td>1</td><td>2</td><td>4</td><td>8</td><td>12</td><td>16</td></tr><tr><td rowspan="2">Supervised</td><td>Random</td><td>99.5</td><td>99.5</td><td>99.3</td><td>99.4</td><td>98.9</td><td>98.3</td></tr><tr><td>In-grid</td><td>99.5</td><td>99.6</td><td>99.5</td><td>99.3</td><td>98.6</td><td>92.4</td></tr><tr><td rowspan="2">SimCLR</td><td>Random</td><td>98.9</td><td>98.9</td><td>99.0</td><td>98.9</td><td>98.2</td><td>96.4</td></tr><tr><td>In-grid</td><td>98.3</td><td>98.6</td><td>99.1</td><td>99.2</td><td>99.1</td><td>98.3</td></tr></table>
+
+# 3.2 SimCLR learns local features that exhibit hierarchical properties
+
+To understand the local features learned by SimCLR, we apply K-means on intermediate features of the pretrained ResNet with SimCLR, and see how local regions of an image are grouped together. For good representations, we expect that regions of similar objects or object parts should be grouped together.
+
+Specifically, we take a pretrained Resnet- $5 0 2 \times$ on ImageNet, and run inference on images (from ImageNet validation set and COCO [23]) of size $4 4 8 \times 4 4 8$ . We run K-means with various numbers of clusters on the l2-normalized hidden features from middle layers of the network (e.g. block group 2,3,4 of the ResNet). We also compare SimCLR learned features with supervised learned features, as well as the raw pixel (RGB) features extracted from each $1 4 \times 1 4$ patch.
+
+Figure 3a shows that as the number of clusters increases, the learned representations tend to group image regions based on parts of the object (i.e. facial components of the dog). This phenomenon appears in both SimCLR and supervised learned features, but not with raw pixel features, indicating meaningful local features learned by SimCLR and supervised learning. In Figure 3b, we compare ResNet intermediate features at different layers, and it suggests that earlier layers contain more edge-related features, while later layers contain more object/part features.
+
+![](images/043491355a096c32ce3d26731e8d7e91ef6ef346ae1830e7b7ba567dee42aa4e.jpg)  
+Figure 3: Visualizing features on a ImageNet validation image with K-means clustering. Each row denotes a type of local features used, and each column denotes the number of K-means clusters. Later layers of SimCLR/supervised ResNet tend to group by object parts. More visualization examples can be found in https://contrastive-learning.github.io/intriguing.
+
+![](images/4abcffd2abc33c1ac2982c97c9aa7b81d6dbcd9f72ed0faee407ee9907b9e2b0.jpg)  
+Figure 4: Visualizing features on two images from COCO. Each row denotes a type of local features (SimCLR, Supervised, and raw pixels; both SimCLR and Supervised are trained on ImageNet), and each column denotes the number of K-means clusters. Region grouping by SimCLR/supervised features tend to overlap with object class.
+
+Region grouping results on two COCO images for SimCLR and supervised learning (trained on ImageNet) are shown in Figure 4. Again, region grouping by local features tend to overlap with object class, indicating good local features learned.
+
+# 4 Feature suppression limits the potential of contrastive learning
+
+Contrastive learning requires good design of data augmentation to work well. As shown in [13], without color augmentations that randomly shift color distribution (while maintaining information regarding object class), the quality of learned representations are significantly worse. In other words, the presence of “color distribution” features suppresses their competing feature of “object class”, and is addressed by color augmentation. However, there may be scenarios where the known augmentations cannot fully address this feature suppression effect, and it can thus limit the potential of contrastive learning. Here we quantitatively study the feature suppression phenomenon by constructing datasets with explicit and controllable competing features, and see how well contrastive learning method could learn.
+
+![](images/2d24a657de9002696702a1f1f3f206b04f81b0e136641be565d7250e4cbfd08a.jpg)
+
+(a) ImageNet images overlaid with MNIST digits. The left most column is original image, and others are augmented views via random crop and color distortion. MNIST digits and ImageNet classes are competing features. We vary the number of unique MNIST digits to control the competing features.
+
+![](images/9f7491107755ce039f3ec5e905e7aac4cdee2a3b3d886f2a7809a848aaa2d3e2.jpg)
+
+(b) Two MNIST digits randomly placed on a shared canvas (of size $1 1 2 \times 1 1 2 )$ . The two digits can have the same size (upper row) or different sizes (lower row), and digits of different sizes can be considered as competing features. We fix the size of one digit and vary the other.
+
+![](images/081d486d795cdcd891fae2fb1694148acdc8a72f06d343a13fdf2aec95006645.jpg)  
+Figure 5: Probing datasets with explicit and controllable competing features.
+
+(c) Images (of RGB channels) are concatenated with additional channels of random integer sampled from range of $[ 1 , \log _ { 2 } ( n ) ]$ . The integer, shared between two views, is replicated for spatial dimension and represented as $n$ binary channels. RGB channels and random bits are competing features.
+
+# 4.1 Datasets with explicit and controllable competing features
+
+To construct datasets with controllable competing features, we leverage two strategies: channel addition that adds different feature information in a shared canvas, and channel concatenation that expand the RGB channels to include additional features. With these strategies, we construct three datasets below.
+
+DigitOnImageNet dataset. We overlay MNIST digits on ImageNet images via channel addition/summation (Figure 5a). For each ImageNet image, we assign a unique MNIST digit and replicate it in nine fixed locations before the standard SimCLR augmentations [13] are applied to create augmented views. Therefore the original ImageNet images and added MNIST digits are competing features. Although it is difficult to quantify information in MNIST digits, we can manually control the number of unique MNIST digits used. Ideally, we want the model to learn both set of features so that it could perform well for both MNIST digit and ImageNet object recognition.
+
+MultiDigits dataset (varying the size of one digit). This dataset is modified from MultiDigits introduced above. Here we only consider two digits, and vary the size of one of them (Figure 5b). In this work, we place two digits on a canvas of size $1 1 2 \times 1 1 2$ . We fix the size of one of the digits to be $2 0 \times 2 0$ while varying the other from $2 0 \times 2 0$ to $8 0 \times 8 0$ . Digits of different sizes can be considered as competing features. Ideally, we want the model to learn features for digits of all sizes appeared during training.
+
+RandBit dataset. We concatenate a real image with an image of a random integer in the channel dimension (Figure 5c). The random integer is randomly sampled from range of $[ 1 , \log _ { 2 } ( n ) ]$ where $n$ is a parameter to control. It is replicated across spatial dimension (i.e. all pixel location shares the same value), and it is also represented as $n$ binary bits/channels instead of an integer or floating number to make it easily learnable. Furthermore, unlike RGB channels, these additional channels of random bits will not be altered by augmentation, so they are identical for both augmented views of the same image. The RGB channels and the added channels of random bits are competing features, and this construction allows us to control the amount of information in the added competing feature, which is $n$ bits. Also, we know that the mutual information between two views given this construction is at least $\log _ { 2 } ( n )$ .
+
+![](images/acfe4178ba9ddc62ef5a9895c5449a4629859731538e08911841be4b0f7c777d.jpg)  
+4.2 Easy-to-learn features (MNIST digit) suppress the learning of other features (ImageNet object class)   
+Figure 6: (a) Supervised learning accuracy on ImageNet classification. (b) Linear evaluation of learned features for both MNIST classification and ImageNet classification on the DigitOnImageNet dataset. Batch size of 1024 and 2-layer projection head is used. Different batch sizes and projection head layers have negligible influence on the trade-off between ImageNet vs MNIST accuracy.
+
+On DigitOnImageNet datasets, we vary the number of unique MNIST digits used in the training set, and all MNIST digits are used in the validation/test set. As a baseline, we train supervised ResNet-50 on the created datasets with ImageNet labels, and the number of unique MNIST digits has little impact on the top-1 ImageNet classification accuracy (Figure 6a).
+
+We then train SimCLR on the datasets with different temperatures. As shown in Figure 6b, when we increase the number of unique MNIST digits, the linear evaluation performance of the learned features for MNIST classes increases accordingly, while the accuracy for ImageNet classes decreases dramatically. The trade-off between digit recognition ability and object recognition ability shows that simple features suppress the learning of difficult features, when both are shared between two augmented views. Different batch sizes and projection head depths have negligible influence to the outcome we observe here. Therefore, it is difficult to learn both of the competing features using existing contrastive losses (e.g. SimCLR).
+
+# 4.3 The presence of dominant object suppresses the learning of features of smaller objects
+
+On the MultiDigits dataset, as mentioned, we fix one digit to be size of $2 0 \times 2 0$ while varying the other from $2 0 \times 2 0$ to $8 0 \times 8 0$ , on a canvas of $1 1 2 \times 1 1 2$ . We first pretrain a ResNet-18 with SimCLR or supervised learning with the same augmentation policy (random cropping and resize) and batch size of 1024. To access the representation quality, we then train linear classifiers for each of the digit sizes that appeared during pretraining. For training of the linear classifier, we only place a single digit at a time on the canvas of the same size as during pretraining.
+
+The results are summarized in Table 4. For supervised learning, the learned representations for the smaller digit do not change much as the other digit increases its size, and the model perform well for both small and large digits (accuracy $> 9 9 \%$ ). However, for SimCLR, the learned representations of the smaller digit degenerate significantly when the size of the other digit increases, almost to the level of a random untrained network. The dominant object can be learned very well (accuracy $> 9 9 \%$ ) while suppressing the learning of the smaller object. Although tuning temperature has some effects on reducing the feature suppression, the trend stays unchanged.
+
+Table 4: Top-1 linear evaluation accuracy $( \% )$ for pretrained ResNet-18 on the MultiDigits dataset. We fix the size of 1st digit while increasing the size of the 2nd digit. For SimCLR, results are presented for two temperatures. Accuracies suffered from a significant drop when increasing 2nd digit size are red colored.   
+
+<table><tr><td></td><td></td><td colspan="7">2nd digit size (1st digit is kept the same size of 20 × 20)</td></tr><tr><td></td><td></td><td>20×20</td><td>30×30</td><td>40×40</td><td>50×50</td><td>60×60</td><td>70×70</td><td>80×80</td></tr><tr><td rowspan="2">Supervised</td><td>1st digit</td><td>99.1</td><td>99.2</td><td>99.2</td><td>99.2</td><td>99.1</td><td>99.1</td><td>99.0</td></tr><tr><td>2nd digit</td><td>99.1</td><td>99.5</td><td>99.5</td><td>99.6</td><td>99.5</td><td>99.5</td><td>99.6</td></tr><tr><td rowspan="2">SimCLR (t = 0.05)</td><td>1st digit</td><td>97.8</td><td>97.6</td><td>96.2</td><td>96.5</td><td>88.5</td><td>74.5</td><td>39.9</td></tr><tr><td>2nd digit</td><td>97.8</td><td>97.9</td><td>97.8</td><td>98.3</td><td>98.2</td><td>97.7</td><td>98.2</td></tr><tr><td rowspan="2">SimCLR (T = 0.2)</td><td>1st digit</td><td>98.7</td><td>98.8</td><td>98.3</td><td>87.5</td><td>24.9</td><td>19.8</td><td>20.3</td></tr><tr><td>2nd digit</td><td>98.7</td><td>99.2</td><td>99.2</td><td>99.0</td><td>99.1</td><td>98.9</td><td>99.4</td></tr><tr><td rowspan="2">Random net (untrained)</td><td>1st digit</td><td>16.5</td><td>16.7</td><td>16.6</td><td>16.6</td><td>16.6</td><td>16.9</td><td>16.5</td></tr><tr><td>2nd digit</td><td>16.5</td><td>19.1</td><td>21.9</td><td>24.1</td><td>26.5</td><td>28.1</td><td>29.0</td></tr></table>
+
+# 4.4 Extra channels with a few bits of easy-to-learn mutual information suppress the learning of all features in RGB channels
+
+In the RandBit datasets, we add additional channels (identical across pixels) of random bits to MNIST and ImageNet. As mentioned above, SimCLR augmentation is only applied to RGB channels so extra added channels will be shared among two view.
+
+![](images/5eb27c72fac25f6634e9c79d0a24735a1a738b8e428b8cb474fa9e027848f287.jpg)  
+Figure 7: Linear evaluation of learned features when a few bits of competing features added (on MNIST). Adding a few bits completely disables contrastive learning (across various batch size or losses). Interestingly, it has little effects on a generative model (VAE). The detrimental effects are just as strong for larger datasets such as CIFAR-10 and ImageNet (Appendix B.1).
+
+Figure 7 shows the linear evaluation accuracy of models trained on MNIST (with additional random bits added). We observe that the linear evaluation accuracy quickly drops with a few bits of competing feature added. This detrimental effect on the representation quality persists on bigger datasets like CIFAR-10 and ImageNet as well, and cannot be avoided by using different contrastive losses, batch sizes, or memory mechanism based on momentum contrast (details in Appendix B.1). We believe the fact that just a few bits of easy-to-learn features can completely disable the good representation learning is related to the saturation of the distribution matching loss. As shown in Appendix B.2, the linear increase in bits requires an exponential increase in batch size, which is not sustainable as the required batch size can quickly go beyond the size of the dataset size. In practice, we rely on using data augmentation to remove those uninformative easy-to-learn features so that contrastive learning can learn useful representations. Interestingly, the extra bits do not affect a generative model, variational autoencoder [24, 25], nearly as much, despite other settings such as model size are held the same, prompting a potential direction of addressing the issue.
+
+# 5 Related Work
+
+Our work studies the contrastive loss based on cross entropy loss [15, 3, 4, 13]. This loss is widely used in recent successful contrastive learning methods [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]. In terms of the contrastive loss, our work is perhaps most related to [16], which shows that formulating contrastive loss as alignment and uniformity in the hypersphere gives similar performance as the standard contrastive loss. We further generalize this factorization, and show other distribution matching losses can be used, and they could achieve similar results. Other than standard contrastive loss that directly utilize negative examples, BYOL [22] demonstrates another way to maintain representation distribution/entropy without directly relying on distribution matching, and SWAV [26] shows clustering-based method equipped with proper data augmentations could also achieve similar performance. We conduct preliminary experiments of BYOL on RandBit and found that it also suffers from feature suppression as generalized contrastive loss. It is expected that SWAV would exhibit similar behaviors on RandBit as those random bits could fuel representations for perfect clustering.
+
+The connection between contrastive loss and mutual information has been studied before [3, 20]. We show that for the generalized contrastive loss, it can also be related to mutual information. Despite the connection between contrastive loss and mutual information, it has been pointed out that mutual information estimation may suffer from certain limitations [27, 28]. Moreover, [29, 12] show that higher mutual information learned by the network does not warrant better representation quality. In our work, we find adding mutual information bits between two views which are irrelevant to downstream tasks can be harmful for the quality of learned representations. Data augmentation plays an important role at favoring certain bits of mutual information than others.
+
+There is a growing number of recent work on the topic of understanding contrastive learning, both theoretically [30, 31, 32, 33, 34] and empirically [16, 12, 35, 36]. However, little work has been done to study the phenomenon of feature suppression. To our knowledge, we are the first one to quantitatively and systematically study this problem. We believe this is still a very open question and could benefit from more future investigation. Finally, the feature suppression effect in unsupervised contrastive learning that we study in this work may also exist in standard supervised learning (“contrastive loss” between examples and class labels), as suggested by [37, 38], though the specific form would be different.
+
+# 6 Conclusion
+
+In this work, we study three intriguing properties of contrastive losses. In particular, our results highlight that feature suppression is still an open challenge in contrastive learning. While there is a plethora of work on improving contrastive learning, few of them directly aim to address feature suppression. This limitation of contrastive learning becomes a bottleneck for scenarios where existing augmentation cannot fully address the feature suppression phenomenon, and learning would saturate at a level of dissatisfaction.
+
+We would also like to point out some limitations of our study. Firstly, we focus mostly on contrastive learning with explicit negatives (e.g. SimCLR and MoCo). We believe other methods based on clustering and/or without negative pairs would exhibit similar phenomenon but we leave that as future work. Secondly, many of our proposed image datasets are not fully realistic despite being composed from some (challenging) natural image datasets such as ImageNet. We admit it is very hard to explore competing features or multiple objects in a controllable fashion on realistic large scale image datasets.
+
+# Acknowledgements
+
+We specially thank Geoffrey Hinton for many inspiring discussions and helpful advice. We would also like to thank David Fleet, Simon Kornblith, Mohammad Norouzi, Kevin Swersky and Katherine Hermann for insightful discussions. In addition, we are thankful to William Chan and Sara Sabour for ideas on implementation of sorting on TPUs. We also thank the anonymous reviewers for their constructive feedback.
+
+References   
+[1] Suzanna Becker and Geoffrey E Hinton. Self-organizing neural network that discovers surfaces in randomdot stereograms. Nature, 355(6356):161–163, 1992.   
+[2] Alexey Dosovitskiy, Jost Tobias Springenberg, Martin Riedmiller, and Thomas Brox. Discriminative unsupervised feature learning with convolutional neural networks. In Advances in neural information processing systems, pages 766–774, 2014.   
+[3] Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.   
+[4] Zhirong Wu, Yuanjun Xiong, Stella X Yu, and Dahua Lin. Unsupervised feature learning via nonparametric instance discrimination. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3733–3742, 2018.   
+[5] R Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Phil Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. arXiv preprint arXiv:1808.06670, 2018.   
+[6] Philip Bachman, R Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. In Advances in Neural Information Processing Systems, pages 15509–15519, 2019.   
+[7] Olivier J Hénaff, Ali Razavi, Carl Doersch, SM Eslami, and Aaron van den Oord. Data-efficient image recognition with contrastive predictive coding. arXiv preprint arXiv:1905.09272, 2019.   
+[8] Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. arXiv preprint arXiv:1906.05849, 2019.   
+[9] Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representations. arXiv preprint arXiv:1912.01991, 2019.   
+[10] Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. arXiv preprint arXiv:1911.05722, 2019.   
+[11] Junnan Li, Pan Zhou, Caiming Xiong, Richard Socher, and Steven CH Hoi. Prototypical contrastive learning of unsupervised representations. arXiv preprint arXiv:2005.04966, 2020.   
+[12] Yonglong Tian, Chen Sun, Ben Poole, Dilip Krishnan, Cordelia Schmid, and Phillip Isola. What makes for good views for contrastive learning. arXiv preprint arXiv:2005.10243, 2020.   
+[13] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. arXiv preprint arXiv:2002.05709, 2020.   
+[14] Ting Chen, Simon Kornblith, Kevin Swersky, Mohammad Norouzi, and Geoffrey Hinton. Big selfsupervised models are strong semi-supervised learners. arXiv preprint arXiv:2006.10029, 2020.   
+[15] Kihyuk Sohn. Improved deep metric learning with multi-class n-pair loss objective. In Advances in neural information processing systems, pages 1857–1865, 2016.   
+[16] Tongzhou Wang and Phillip Isola. Understanding contrastive representation learning through alignment and uniformity on the hypersphere. arXiv preprint arXiv:2005.10242, 2020.   
+[17] Julien Rabin, Gabriel Peyré, Julie Delon, and Marc Bernot. Wasserstein barycenter and its application to texture mixing. In International Conference on Scale Space and Variational Methods in Computer Vision, pages 435–446. Springer, 2011.   
+[18] Nicolas Bonneel, Julien Rabin, Gabriel Peyré, and Hanspeter Pfister. Sliced and radon wasserstein barycenters of measures. Journal of Mathematical Imaging and Vision, 51(1):22–45, 2015.   
+[19] Soheil Kolouri, Kimia Nadjahi, Umut Simsekli, Roland Badeau, and Gustavo Rohde. Generalized sliced wasserstein distances. In Advances in Neural Information Processing Systems, pages 261–272, 2019.   
+[20] Ben Poole, Sherjil Ozair, Aaron van den Oord, Alexander A Alemi, and George Tucker. On variational bounds of mutual information. arXiv preprint arXiv:1905.06922, 2019.   
+[21] Yang You, Igor Gitman, and Boris Ginsburg. Large batch training of convolutional networks. arXiv preprint arXiv:1708.03888, 2017.   
+[22] Jean-Bastien Grill, Florian Strub, Florent Altché, Corentin Tallec, Pierre H. Richemond, Elena Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, Bilal Piot, Koray Kavukcuoglu, Rémi Munos, and Michal Valko. Bootstrap your own latent: A new approach to selfsupervised learning, 2020.   
+[23] 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.   
+[24] Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.   
+[25] Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. arXiv preprint arXiv:1401.4082, 2014.   
+[26] Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments. arXiv preprint arXiv:2006.09882, 2020.   
+[27] David McAllester and Karl Stratos. Formal limitations on the measurement of mutual information. In International Conference on Artificial Intelligence and Statistics, pages 875–884, 2020.   
+[28] Jiaming Song and Stefano Ermon. Understanding the limitations of variational mutual information estimators. arXiv preprint arXiv:1910.06222, 2019.   
+[29] Michael Tschannen, Josip Djolonga, Paul K Rubenstein, Sylvain Gelly, and Mario Lucic. On mutual information maximization for representation learning. arXiv preprint arXiv:1907.13625, 2019.   
+[30] Sanjeev Arora, Hrishikesh Khandeparkar, Mikhail Khodak, Orestis Plevrakis, and Nikunj Saunshi. A theoretical analysis of contrastive unsupervised representation learning. arXiv preprint arXiv:1902.09229, 2019.   
+[31] Yao-Hung Hubert Tsai, Yue Wu, Ruslan Salakhutdinov, and Louis-Philippe Morency. Demystifying self-supervised learning: An information-theoretical framework. arXiv preprint arXiv:2006.05576, 2020.   
+[32] Christopher Tosh, Akshay Krishnamurthy, and Daniel Hsu. Contrastive learning, multi-view redundancy, and linear models. arXiv preprint arXiv:2008.10150, 2020.   
+[33] Yuandong Tian, Lantao Yu, Xinlei Chen, and Surya Ganguli. Understanding self-supervised learning with dual deep networks. arXiv preprint arXiv:2010.00578, 2020.   
+[34] Jason D Lee, Qi Lei, Nikunj Saunshi, and Jiacheng Zhuo. Predicting what you already know helps: Provable self-supervised learning. arXiv preprint arXiv:2008.01064, 2020.   
+[35] Nanxuan Zhao, Zhirong Wu, Rynson WH Lau, and Stephen Lin. What makes instance discrimination good for transfer learning? arXiv preprint arXiv:2006.06606, 2020.   
+[36] Senthil Purushwalkam and Abhinav Gupta. Demystifying contrastive self-supervised learning: Invariances, augmentations and dataset biases. arXiv preprint arXiv:2007.13916, 2020.   
+[37] Katherine L Hermann and Andrew K Lampinen. What shapes feature representations? exploring datasets, architectures, and training. arXiv preprint arXiv:2006.12433, 2020.   
+[38] Harshay Shah, Kaustav Tamuly, Aditi Raghunathan, Prateek Jain, and Praneeth Netrapalli. The pitfalls of simplicity bias in neural networks. arXiv preprint arXiv:2006.07710, 2020.   
+[39] 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, pages 770–778, 2016.

parse/train/rYhBGWYm6AU/rYhBGWYm6AU_content_list.json

@@ -0,0 +1,1015 @@
+[
+    {
+        "type": "text",
+        "text": "Intriguing Properties of Contrastive Losses ",
+        "text_level": 1,
+        "bbox": [
+            235,
+            122,
+            761,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ting Chen Google Research iamtingchen@google.com ",
+        "bbox": [
+            222,
+            200,
+            393,
+            243
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Calvin Luo Google Research calvinluo@google.com ",
+        "bbox": [
+            447,
+            200,
+            604,
+            243
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Lala Li Google Research lala@google.com ",
+        "bbox": [
+            658,
+            200,
+            774,
+            243
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            279,
+            535,
+            295
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We study three intriguing properties of contrastive learning. First, we generalize the standard contrastive loss to a broader family of losses, and we find that various instantiations of the generalized loss perform similarly under the presence of a multi-layer non-linear projection head. Second, we study if instance-based contrastive learning (with a global image representation) can learn well on images with multiple objects present. We find that meaningful hierarchical local features can be learned despite the fact that these objectives operate on global instancelevel features. Finally, we study the phenomenon of feature suppression among competing features shared across augmented views, such as “color distribution” vs “object class”. We construct datasets with explicit and controllable competing features and show that, for contrastive learning, a few bits of easy-to-learn shared features can suppress, and even fully prevent, the learning of other sets of competing features. In scenarios where there are multiple objects in an image, the dominant object would suppress the learning of smaller objects. Existing contrastive learning methods critically rely on data augmentation to favor certain sets of features over others, and could suffer from learning saturation for scenarios where existing augmentations cannot fully address the feature suppression. This poses open challenges to existing contrastive learning techniques 1. ",
+        "bbox": [
+            233,
+            310,
+            766,
+            559
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            587,
+            310,
+            603
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Contrastive learning [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] has recently achieved great successes in learning visual representations without supervision. As shown in [13, 14], contrastive learning can learn representations that rival supervised learning, and significantly improve the state-of-the-art in semi-supervised learning on ImageNet. One successful use case of contrastive loss for self-supervised learning is to make augmented views of the same example agree [1, 2, 13]. A widely used contrastive loss to encourage agreement is based on cross entropy [15, 3, 4, 13]. Given an augmented view of an example, the contrastive prediction task aims to classify a set of candidates into the positive example (i.e. the other augmented view of the same example) and negative ones via the cross entropy loss. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            729
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, to understand the effectiveness and limitation of existing contrastive learning methods, we study three intriguing aspects. First, we propose a generalization of the standard contrastive loss, and systematically study their performance differences. Second, we study if the instance-based contrastive learning, for which the contrastive loss operates on global representation of an input image, can learn well on images with multiple objects present, and whether or not it leads to meaningful local features. Finally, we systematically study the feature suppression phenomenon in contrastive learning. The suppression effect occurs among competing features shared across augmented views. For example, with random cropping as the augmentation, “color distribution” and “object class” are often competing features as they are likely shared between two augmented views. The suppression effect among competing features can significantly degenerate the representation quality, or even completely disable the learning of certain features, as shown in our experiments. Existing methods critically rely on hand-crafted data augmentation to favor certain sets of competing features than others. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            873
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our main findings and contributions are summarized below. ",
+        "bbox": [
+            174,
+            138,
+            566,
+            154
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose a generalized contrastive loss, and show that differences between contrastive losses are small with a deep projection head.   \n• We show that the instance-based objective widely used in existing contrastive learning methods can learn on images with multiple objects, and also learn meaningful local features despite operating on global image representation.   \n• We construct three datasets with explicit and controllable competing features to systematically study the feature suppression effect in contrastive learning.   \n• We show that a few bits of easy-to-learn shared features can suppress, and even fully prevent, the learning of other sets of competing features. In scenarios where there are multiple objects in an image, the dominant object would suppress the learning of smaller objects. This poses open challenges to existing contrastive learning. ",
+        "bbox": [
+            181,
+            160,
+            826,
+            332
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Generalized contrastive loss and differences among its instantiations ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            349,
+            774,
+            367
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The common contrastive loss used in most recent work is based on cross entropy [15, 3, 4]. Following the notation in [13], the contrastive loss can be defined between two augmented views $( i , j )$ of the same example for a mini-batch of size of $n$ , and can be written as the following. ",
+        "bbox": [
+            174,
+            380,
+            825,
+            422
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/29b537f8d27e012e5ac872acf55cf4fe9b069f335f4d210c3543bb91a9c52772.jpg",
+        "text": "$$\n\\mathcal { L } ^ { \\mathrm { N T - X e n t } } = - \\frac { 1 } { n } \\sum _ { i , j \\in \\mathcal { M B } } \\log \\frac { \\exp ( \\sin ( z _ { i } , z _ { j } ) / \\tau ) } { \\sum _ { k = 1 } ^ { 2 n } \\mathbb { 1 } _ { [ k \\neq i ] } \\exp ( \\sin ( z _ { i } , z _ { k } ) / \\tau ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            438,
+            691,
+            474
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $z _ { i } , z _ { j }$ are hidden representations of two augmented views of the same example; $\\sin ( { \\boldsymbol { \\mathbf { u } } } , { \\boldsymbol { \\mathbf { v } } } ) =$ $\\pmb { u } ^ { T } \\pmb { v } / ( \\lVert \\pmb { u } \\rVert \\lVert \\pmb { v } \\rVert )$ is the cosine similarity between two vectors; $\\tau$ is a temperature scalar and $\\mathcal { M } \\mathcal { B }$ is a randomly sampled mini-batch consisting of augmented pairs of images. In [13], a MLP projection head is introduced between intermediate layer $^ { h }$ (e.g. output of ResNet encoder) and final output $_ { z }$ . It is shown that the projection head is very beneficial and $^ { h }$ is a much better feature representation than $_ { z }$ . ",
+        "bbox": [
+            173,
+            481,
+            826,
+            566
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we generalize the standard contrastive loss to the following form. ",
+        "bbox": [
+            173,
+            571,
+            689,
+            588
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1eaa63438cc08e864f99d7dfab6ddcbe330b877c50b2333022d89fc69fe9d5a8.jpg",
+        "text": "$$\n\\boxed { \\mathcal { L } _ { \\mathrm { g e n e r a l i z e d c o n t r a s t i v e } } = \\mathcal { L } _ { \\mathrm { a l i g n m e n t } } + \\lambda \\mathcal { L } _ { \\mathrm { d i s t r i b u t i o n } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            603,
+            651,
+            626
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Both terms are defined on hidden representations. $\\mathcal { L } _ { \\mathrm { a l i g n m e n t } }$ encourages representations of augmented views to be consistent, while ${ \\mathcal { L } } _ { \\mathrm { d i s t r i b u t i o n } }$ encourages representations (or a random subset of them) to match a prior distribution (of high entropy). It is not difficult to see that the standard contrastive loss in Eq. 1 is a special case as it can be re-written as follows (scaled by a constant $\\tau$ ). ",
+        "bbox": [
+            174,
+            645,
+            825,
+            700
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/740f495d4c71eaca9395db0658aa3be3befa543e2227a8896736fe0980a7fc51.jpg",
+        "text": "$$\n\\tau \\mathcal { L } ^ { \\mathrm { N T - X e n t } } = \\underbrace { - \\frac { 1 } { n } \\sum _ { i , j } \\sin ( z _ { i } , z _ { j } ) } _ { \\mathcal { L } _ { \\mathrm { a l i g n m e n t } } } + \\underbrace { \\frac { \\tau } { n } \\sum _ { i } \\log \\sum _ { k = 1 } ^ { 2 n } \\mathbb { 1 } _ { [ k \\neq i ] } \\exp ( \\sin ( z _ { i } , z _ { k } ) / \\tau ) } _ { \\mathcal { L } _ { \\mathrm { d i s t r i b u t i o n } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            717,
+            738,
+            779
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This form of factorization in Eq. 3 has been proposed in [16], where the second LogSumExp term is referred to as uniformity since it encourages representation to uniformly distributed in the hypersphere. Different from [16], here we generalize the hypersphere uniform distribution and study a wider set of prior distributions for their effectiveness in learning representations. ",
+        "bbox": [
+            178,
+            785,
+            823,
+            842
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "SWD for supporting diverse prior distributions. One issue of using more diverse set of priors is we cannot rely on LogSumExp for matching the distribution. To this end, we resort to the theory of optimal transport, via Sliced Wasserstein Distance (SWD) [17, 18, 19]. For two sets of equalsized samples from two 1-D distributions, the optimal transport can be obtained by computing two permutations that order the values of both sets of samples respectively. The 1-D Wasserstein distance can then be computed with $\\ell _ { 2 }$ distance between the ordered values. For n-D distributions, we first project the samples to $n$ randomly-generated orthogonal 1-D subspaces, and then compute the sum of 1-D Wasserstein distance across all 1-D subspaces. By adjusting the network weights to minimize the SWD, we are able to reduce the mismatch between the distribution of hidden vectors and a known prior distribution. The detailed algorithm can be found in Algorithm 1. With SWD loss, we are able to use a wider set of priors, and Table 1 summarizes instantiations of the generalized contrastive loss with different prior distributions and distribution matching loss. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/d5fec96aeacddf4b8573946c705bda47855c02a443ededef1bf933e289a56ed0.jpg",
+        "table_caption": [
+            "Algorithm 1 Sliced Wasserstein Distance (SWD) loss. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>input: activation vectors H ∈ Rb×d, ,a prior distribution (e.g. Gaussian) sampler S draw prior vectors P ∈ Rb×d using S</td></tr><tr><td></td></tr><tr><td>generate random orthogonal matrix W ∈ Rd×d&#x27;</td></tr><tr><td>make projections: H-= HW; P⊥ = PW</td></tr><tr><td>initializeSWDlossl=0</td></tr><tr><td>forj∈{1,2,.,d&#x27;} do l =l+ |lsort(H:j)-sort(P:j)|l²</td></tr><tr><td></td></tr><tr><td>end for return l/(dd&#x27;)</td></tr></table>",
+        "bbox": [
+            178,
+            109,
+            738,
+            246
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/3a3eed4a2d996e3879ad40c806cc09b248123762a01c1400080926cb0ca874a6.jpg",
+        "table_caption": [
+            "Table 1: Instantiations of the generalized contrastive loss, i.e. $\\mathcal { L } _ { \\mathrm { a l i g n m e n t } } + \\lambda \\mathcal { L } _ { \\mathrm { d i s t r i b u t i o n } }$ , that we use in this work. $\\tilde { z }$ denotes $\\ell _ { 2 }$ -normalized $z \\in \\mathbb { R } ^ { d }$ , and is only used for uniform hypersphere prior. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Laign</td><td>Prior distribution</td><td>Ldistribution</td></tr><tr><td>nd∑i, |lzi - zj|l²Uniform hypersphere</td><td></td><td>e∑log∑exp(Tzj/T）</td></tr><tr><td>nd∑ij |lz- zjll2Uniform hypersphere</td><td></td><td>SWD(Z, zprior)</td></tr><tr><td>d∑ij|lz-zjll²Uniform hypercube</td><td></td><td>SWD(Z, Zprior)</td></tr><tr><td>nd∑i,j |lzi - zjll2Normal distribution</td><td></td><td>SWD(Z, Zprior)</td></tr></table>",
+        "bbox": [
+            256,
+            303,
+            740,
+            411
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            443,
+            825,
+            554
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Connection with mutual information. The connection between the standard contrastive loss and mutual information has been shown before [3, 20], where the contrastive loss (a.k.a. InfoNCE loss [3]) is shown to be a lower bound of the mutual information. To connect the generalized contrastive loss to mutual information, we start by the definition of mutual information between two latent variables $U , V$ , which is $I ( U ; V ) = H ( U ) - H ( U | V )$ . Comparing this factorization of mutual information with generalized contrastive loss, it is not difficult to see that: 1) the alignment term $\\mathcal { L } _ { \\mathrm { a l i g n m e n t } }$ is directly related to $H ( U | V )$ which aims to reduce uncertainty of the other views given one view of the example; and 2) the distribution matching term ${ \\mathcal { L } } _ { \\mathrm { d i s t r i b u t i o n } }$ can be considered as a proxy to $H ( u )$ for maximizing the entropy in the representation. It is perhaps worth noting that different from mutual information, the generalized contrastive loss (Eq. 2) allows a tunable weight $( \\lambda )$ between the alignment and distribution matching term. The weighting scalar $\\lambda$ is (inversely) related to the temperature $\\tau$ (details in Appendix A.2). ",
+        "bbox": [
+            173,
+            575,
+            825,
+            742
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Comparing different instantiations of generalized contrastive loss. Here we ask: Is it essential to use a uniform hypersphere prior for the effectiveness of contrastive loss? How much difference does it make when distinct generalized contrastive losses are used? To answer this question, we conduct experiments following SimCLR settings [13, 14], and use the linear evaluation protocol. Detailed experimental setup can be found in Appendix A.1. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 shows linear evaluation results of models trained with different losses under different training epochs. On CIFAR-10, we see little difference in terms of linear evaluation for variants of the generalized contrastive losses, especially when trained longer than 200 epochs. As for ImageNet, there are some discrepancies between different losses, but they disappear when a deeper 3-layer non-linear projection head is used. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            909
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/b2443f8eabb0e0479457a5400ec51cc75e840fb6d83df72f3695d1b7938e34df.jpg",
+        "image_caption": [
+            "Figure 1: Linear evaluation accuracy of ResNet-50 trained with different losses on CIFAR-10 and ImageNet datasets. Numbers of projection head layers are in parentheses. Differences between variants of generalized contrastive loss are small with a deep projection head. Decoupled NT-Xent loss is introduced in A.2. Numerical results can be found in Appendix A.3. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            85,
+            803,
+            247
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, we find that deep projection head not only reduces the differences among different generalized contrastive losses, but has a similar effect for batch size. With proper learning rate scaling across batch sizes (e.g. square root scaling with LARS optimizer [21]), the impact of batch size on representation quality is small. Table 2 demonstrate this phenomenon for the standard contrastive loss, and more results on other losses can be found in Appendix A.3. ",
+        "bbox": [
+            174,
+            343,
+            408,
+            535
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/2ed625c7bef748f906967df1f45626d85dee7d4e879b7be2b09215328867e8b3.jpg",
+        "table_caption": [
+            "Table 2: Linear eval accuracy of ResNet-50 on ImageNet. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Projection head</td><td rowspan=\"2\">Batch size</td><td colspan=\"4\">Epoch</td></tr><tr><td>100</td><td>200</td><td>400</td><td>800</td></tr><tr><td rowspan=\"3\">2 layers</td><td>512</td><td>65.4</td><td>67.3</td><td>68.7</td><td>69.3</td></tr><tr><td>1024</td><td>65.6</td><td>67.6</td><td>68.8</td><td>69.8</td></tr><tr><td>2048</td><td>65.3</td><td>67.6</td><td>69.0</td><td>70.1</td></tr><tr><td rowspan=\"3\">3 layers</td><td>512</td><td>66.6</td><td>68.4</td><td>70.0</td><td>71.0</td></tr><tr><td>1024</td><td>66.8</td><td>68.9</td><td>70.1</td><td>70.9</td></tr><tr><td>2048</td><td>66.8</td><td>69.1</td><td>70.4</td><td>71.3</td></tr><tr><td rowspan=\"3\">4 layers</td><td>512</td><td>66.8</td><td>68.8</td><td>70.0</td><td>70.7</td></tr><tr><td>1024</td><td>67.0</td><td>69.0</td><td>70.4</td><td>70.9</td></tr><tr><td>2048</td><td>67.0</td><td>69.3</td><td>70.4</td><td>71.3</td></tr></table>",
+        "bbox": [
+            431,
+            366,
+            808,
+            534
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Instance-based objective can learn on images with multiple objects and learn good local features ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            558,
+            797,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Most existing contrastive learning methods [13, 10, 22, 4] define their objectives at the instance level where each image is encoded into a single vector representation (e.g. representations of two random crops of the same image instance are treated as a positive pair). In other words, the objective operates on a global representation of its input rather than on some local regions (of its input). We pose two questions regarding instance-based global objective: 1) when there is only a single (dominant) object in the image, the objective seems reasonable as it encourages the model to learn features relevant to object class, but when there are multiple objects present in the image, can instance-based objective still learn well? 2) Since the instance-based objective uses a global summary of its input, can it still learn good local features (e.g. parts of an object, or multiple objects in the same scheme)? To answer these questions, we use SimCLR as representative for the instance-based objective. ",
+        "bbox": [
+            173,
+            608,
+            825,
+            747
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 SimCLR can learn on images with multiple objects ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            766,
+            562,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Commonly used self-supervised learning datasets, such as MNIST, CIFAR-10, ImageNet, are object centered, i.e. the image is mainly occupied by a single (dominant) object. To experiment with multiple objects in a controllable setting, we propose a new dataset setting by composing multiple digits as follows. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "MultiDigits dataset. We place MNIST digits ( $2 8 \\times 2 8$ size) on a shared canvas $1 1 2 \\times 1 1 2$ size). We vary the number of digits placed on the canvas. One factor that could interfere with learning of multiple digits is overlapping digits, therefore we use two placement strategies: random vs in-grid (Figure 2). Random placement of digits incurs no constraint on where digits can be placed on the canvas, whereas in-grid placement puts each digit in one of the $4 \\times 4$ grid cells the canvas is divided into, and no two digits can fall in the same cell. In-grid placement ensures no overlapping of digits. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/c71d419367e52d12da14816741144d4a892cd0560eb7e00b6d37305ccc59ec1e.jpg",
+        "image_caption": [
+            "Figure 2: MultiDigit dataset. More digits lead to more overlapping in random placement. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            85,
+            816,
+            215
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            268,
+            823,
+            296
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first pretrain a ResNet-18 with SimCLR or supervised learning with the same augmentation policy (random cropping and resize) on MultiDigits dataset. To access the representation quality, we then train linear classifiers for images with a single digit of size $2 8 \\times 2 8$ on the canvas. Similarly during evaluation, we place only one digit of size $2 8 \\times 2 8$ on the canvas. ",
+        "bbox": [
+            174,
+            303,
+            825,
+            359
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 3, representations learned using supervised loss maintains its quality when up to 8 digits are placed in the image. After that the representation becomes worse as the canvas gets more crowded. Notably, representations learned using SimCLR display a similar phenomenon. Regardless of placement strategy, top-1 accuracy stays at the same level up to 8 digits, demonstrating that SimCLR can learn from images with multiple objects. In addition, the increased performance gap between the two placement strategies with increased number of digits shows that object overlapping makes it harder for contrastive losses to learn from multiple objects. ",
+        "bbox": [
+            174,
+            364,
+            825,
+            462
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/f1aaae4f2fb5d0d1558b8da072cc8a84c49a853ec202e5586d6400e8b9e27272.jpg",
+        "table_caption": [
+            "Table 3: Top-1 linear evaluation accuracy $( \\% )$ for pretrained ResNet-18 on the MultiDigits dataset. We vary the number of digits placed on the canvas during training from 1 to 16. During evaluation only 1 digit is present. As a baseline, a network with random weights gives $18 \\%$ top-1 accuracy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td rowspan=\"2\">Placing of digits</td><td colspan=\"6\">Number of digits (size 28 × 28)</td></tr><tr><td>1</td><td>2</td><td>4</td><td>8</td><td>12</td><td>16</td></tr><tr><td rowspan=\"2\">Supervised</td><td>Random</td><td>99.5</td><td>99.5</td><td>99.3</td><td>99.4</td><td>98.9</td><td>98.3</td></tr><tr><td>In-grid</td><td>99.5</td><td>99.6</td><td>99.5</td><td>99.3</td><td>98.6</td><td>92.4</td></tr><tr><td rowspan=\"2\">SimCLR</td><td>Random</td><td>98.9</td><td>98.9</td><td>99.0</td><td>98.9</td><td>98.2</td><td>96.4</td></tr><tr><td>In-grid</td><td>98.3</td><td>98.6</td><td>99.1</td><td>99.2</td><td>99.1</td><td>98.3</td></tr></table>",
+        "bbox": [
+            259,
+            530,
+            736,
+            628
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 SimCLR learns local features that exhibit hierarchical properties ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            661,
+            665,
+            678
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To understand the local features learned by SimCLR, we apply K-means on intermediate features of the pretrained ResNet with SimCLR, and see how local regions of an image are grouped together. For good representations, we expect that regions of similar objects or object parts should be grouped together. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            746
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Specifically, we take a pretrained Resnet- $5 0 2 \\times$ on ImageNet, and run inference on images (from ImageNet validation set and COCO [23]) of size $4 4 8 \\times 4 4 8$ . We run K-means with various numbers of clusters on the l2-normalized hidden features from middle layers of the network (e.g. block group 2,3,4 of the ResNet). We also compare SimCLR learned features with supervised learned features, as well as the raw pixel (RGB) features extracted from each $1 4 \\times 1 4$ patch. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            821
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 3a shows that as the number of clusters increases, the learned representations tend to group image regions based on parts of the object (i.e. facial components of the dog). This phenomenon appears in both SimCLR and supervised learned features, but not with raw pixel features, indicating meaningful local features learned by SimCLR and supervised learning. In Figure 3b, we compare ResNet intermediate features at different layers, and it suggests that earlier layers contain more edge-related features, while later layers contain more object/part features. ",
+        "bbox": [
+            174,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/043491355a096c32ce3d26731e8d7e91ef6ef346ae1830e7b7ba567dee42aa4e.jpg",
+        "image_caption": [
+            "Figure 3: Visualizing features on a ImageNet validation image with K-means clustering. Each row denotes a type of local features used, and each column denotes the number of K-means clusters. Later layers of SimCLR/supervised ResNet tend to group by object parts. More visualization examples can be found in https://contrastive-learning.github.io/intriguing. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            87,
+            820,
+            292
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/4abcffd2abc33c1ac2982c97c9aa7b81d6dbcd9f72ed0faee407ee9907b9e2b0.jpg",
+        "image_caption": [
+            "Figure 4: Visualizing features on two images from COCO. Each row denotes a type of local features (SimCLR, Supervised, and raw pixels; both SimCLR and Supervised are trained on ImageNet), and each column denotes the number of K-means clusters. Region grouping by SimCLR/supervised features tend to overlap with object class. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            376,
+            821,
+            583
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Region grouping results on two COCO images for SimCLR and supervised learning (trained on ImageNet) are shown in Figure 4. Again, region grouping by local features tend to overlap with object class, indicating good local features learned. ",
+        "bbox": [
+            176,
+            681,
+            825,
+            723
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Feature suppression limits the potential of contrastive learning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            750,
+            725,
+            768
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Contrastive learning requires good design of data augmentation to work well. As shown in [13], without color augmentations that randomly shift color distribution (while maintaining information regarding object class), the quality of learned representations are significantly worse. In other words, the presence of “color distribution” features suppresses their competing feature of “object class”, and is addressed by color augmentation. However, there may be scenarios where the known augmentations cannot fully address this feature suppression effect, and it can thus limit the potential of contrastive learning. Here we quantitatively study the feature suppression phenomenon by constructing datasets with explicit and controllable competing features, and see how well contrastive learning method could learn. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/2d24a657de9002696702a1f1f3f206b04f81b0e136641be565d7250e4cbfd08a.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            89,
+            735,
+            212
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(a) ImageNet images overlaid with MNIST digits. The left most column is original image, and others are augmented views via random crop and color distortion. MNIST digits and ImageNet classes are competing features. We vary the number of unique MNIST digits to control the competing features. ",
+        "bbox": [
+            204,
+            224,
+            787,
+            263
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9f7491107755ce039f3ec5e905e7aac4cdee2a3b3d886f2a7809a848aaa2d3e2.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            251,
+            279,
+            738,
+            349
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(b) Two MNIST digits randomly placed on a shared canvas (of size $1 1 2 \\times 1 1 2 )$ . The two digits can have the same size (upper row) or different sizes (lower row), and digits of different sizes can be considered as competing features. We fix the size of one digit and vary the other. ",
+        "bbox": [
+            200,
+            354,
+            789,
+            393
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/081d486d795cdcd891fae2fb1694148acdc8a72f06d343a13fdf2aec95006645.jpg",
+        "image_caption": [
+            "Figure 5: Probing datasets with explicit and controllable competing features. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            284,
+            411,
+            712,
+            472
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(c) Images (of RGB channels) are concatenated with additional channels of random integer sampled from range of $[ 1 , \\log _ { 2 } ( n ) ]$ . The integer, shared between two views, is replicated for spatial dimension and represented as $n$ binary channels. RGB channels and random bits are competing features. ",
+        "bbox": [
+            204,
+            482,
+            794,
+            521
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 Datasets with explicit and controllable competing features ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            574,
+            614,
+            588
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To construct datasets with controllable competing features, we leverage two strategies: channel addition that adds different feature information in a shared canvas, and channel concatenation that expand the RGB channels to include additional features. With these strategies, we construct three datasets below. ",
+        "bbox": [
+            174,
+            601,
+            825,
+            655
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "DigitOnImageNet dataset. We overlay MNIST digits on ImageNet images via channel addition/summation (Figure 5a). For each ImageNet image, we assign a unique MNIST digit and replicate it in nine fixed locations before the standard SimCLR augmentations [13] are applied to create augmented views. Therefore the original ImageNet images and added MNIST digits are competing features. Although it is difficult to quantify information in MNIST digits, we can manually control the number of unique MNIST digits used. Ideally, we want the model to learn both set of features so that it could perform well for both MNIST digit and ImageNet object recognition. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            761
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "MultiDigits dataset (varying the size of one digit). This dataset is modified from MultiDigits introduced above. Here we only consider two digits, and vary the size of one of them (Figure 5b). In this work, we place two digits on a canvas of size $1 1 2 \\times 1 1 2$ . We fix the size of one of the digits to be $2 0 \\times 2 0$ while varying the other from $2 0 \\times 2 0$ to $8 0 \\times 8 0$ . Digits of different sizes can be considered as competing features. Ideally, we want the model to learn features for digits of all sizes appeared during training. ",
+        "bbox": [
+            173,
+            766,
+            825,
+            849
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "RandBit dataset. We concatenate a real image with an image of a random integer in the channel dimension (Figure 5c). The random integer is randomly sampled from range of $[ 1 , \\log _ { 2 } ( n ) ]$ where $n$ is a parameter to control. It is replicated across spatial dimension (i.e. all pixel location shares the same value), and it is also represented as $n$ binary bits/channels instead of an integer or floating number to make it easily learnable. Furthermore, unlike RGB channels, these additional channels of random bits will not be altered by augmentation, so they are identical for both augmented views of the same image. The RGB channels and the added channels of random bits are competing features, and this construction allows us to control the amount of information in the added competing feature, which is $n$ bits. Also, we know that the mutual information between two views given this construction is at least $\\log _ { 2 } ( n )$ . ",
+        "bbox": [
+            174,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            826,
+            175
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/acfe4178ba9ddc62ef5a9895c5449a4629859731538e08911841be4b0f7c777d.jpg",
+        "image_caption": [
+            "4.2 Easy-to-learn features (MNIST digit) suppress the learning of other features (ImageNet object class) ",
+            "Figure 6: (a) Supervised learning accuracy on ImageNet classification. (b) Linear evaluation of learned features for both MNIST classification and ImageNet classification on the DigitOnImageNet dataset. Batch size of 1024 and 2-layer projection head is used. Different batch sizes and projection head layers have negligible influence on the trade-off between ImageNet vs MNIST accuracy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            258,
+            803,
+            404
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On DigitOnImageNet datasets, we vary the number of unique MNIST digits used in the training set, and all MNIST digits are used in the validation/test set. As a baseline, we train supervised ResNet-50 on the created datasets with ImageNet labels, and the number of unique MNIST digits has little impact on the top-1 ImageNet classification accuracy (Figure 6a). ",
+        "bbox": [
+            174,
+            493,
+            825,
+            549
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We then train SimCLR on the datasets with different temperatures. As shown in Figure 6b, when we increase the number of unique MNIST digits, the linear evaluation performance of the learned features for MNIST classes increases accordingly, while the accuracy for ImageNet classes decreases dramatically. The trade-off between digit recognition ability and object recognition ability shows that simple features suppress the learning of difficult features, when both are shared between two augmented views. Different batch sizes and projection head depths have negligible influence to the outcome we observe here. Therefore, it is difficult to learn both of the competing features using existing contrastive losses (e.g. SimCLR). ",
+        "bbox": [
+            174,
+            556,
+            825,
+            666
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 The presence of dominant object suppresses the learning of features of smaller objects ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            694,
+            807,
+            709
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On the MultiDigits dataset, as mentioned, we fix one digit to be size of $2 0 \\times 2 0$ while varying the other from $2 0 \\times 2 0$ to $8 0 \\times 8 0$ , on a canvas of $1 1 2 \\times 1 1 2$ . We first pretrain a ResNet-18 with SimCLR or supervised learning with the same augmentation policy (random cropping and resize) and batch size of 1024. To access the representation quality, we then train linear classifiers for each of the digit sizes that appeared during pretraining. For training of the linear classifier, we only place a single digit at a time on the canvas of the same size as during pretraining. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            808
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results are summarized in Table 4. For supervised learning, the learned representations for the smaller digit do not change much as the other digit increases its size, and the model perform well for both small and large digits (accuracy $> 9 9 \\%$ ). However, for SimCLR, the learned representations of the smaller digit degenerate significantly when the size of the other digit increases, almost to the level of a random untrained network. The dominant object can be learned very well (accuracy $> 9 9 \\%$ ) while suppressing the learning of the smaller object. Although tuning temperature has some effects on reducing the feature suppression, the trend stays unchanged. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/cd5f56aec9cce63927c852380288fb31382d82accd72859ece7d6ead2ce4eb0e.jpg",
+        "table_caption": [
+            "Table 4: Top-1 linear evaluation accuracy $( \\% )$ for pretrained ResNet-18 on the MultiDigits dataset. We fix the size of 1st digit while increasing the size of the 2nd digit. For SimCLR, results are presented for two temperatures. Accuracies suffered from a significant drop when increasing 2nd digit size are red colored. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td colspan=\"7\">2nd digit size (1st digit is kept the same size of 20 × 20)</td></tr><tr><td></td><td></td><td>20×20</td><td>30×30</td><td>40×40</td><td>50×50</td><td>60×60</td><td>70×70</td><td>80×80</td></tr><tr><td rowspan=\"2\">Supervised</td><td>1st digit</td><td>99.1</td><td>99.2</td><td>99.2</td><td>99.2</td><td>99.1</td><td>99.1</td><td>99.0</td></tr><tr><td>2nd digit</td><td>99.1</td><td>99.5</td><td>99.5</td><td>99.6</td><td>99.5</td><td>99.5</td><td>99.6</td></tr><tr><td rowspan=\"2\">SimCLR (t = 0.05)</td><td>1st digit</td><td>97.8</td><td>97.6</td><td>96.2</td><td>96.5</td><td>88.5</td><td>74.5</td><td>39.9</td></tr><tr><td>2nd digit</td><td>97.8</td><td>97.9</td><td>97.8</td><td>98.3</td><td>98.2</td><td>97.7</td><td>98.2</td></tr><tr><td rowspan=\"2\">SimCLR (T = 0.2)</td><td>1st digit</td><td>98.7</td><td>98.8</td><td>98.3</td><td>87.5</td><td>24.9</td><td>19.8</td><td>20.3</td></tr><tr><td>2nd digit</td><td>98.7</td><td>99.2</td><td>99.2</td><td>99.0</td><td>99.1</td><td>98.9</td><td>99.4</td></tr><tr><td rowspan=\"2\">Random net (untrained)</td><td>1st digit</td><td>16.5</td><td>16.7</td><td>16.6</td><td>16.6</td><td>16.6</td><td>16.9</td><td>16.5</td></tr><tr><td>2nd digit</td><td>16.5</td><td>19.1</td><td>21.9</td><td>24.1</td><td>26.5</td><td>28.1</td><td>29.0</td></tr></table>",
+        "bbox": [
+            176,
+            152,
+            821,
+            314
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 Extra channels with a few bits of easy-to-learn mutual information suppress the learning of all features in RGB channels ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            337,
+            766,
+            364
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the RandBit datasets, we add additional channels (identical across pixels) of random bits to MNIST and ImageNet. As mentioned above, SimCLR augmentation is only applied to RGB channels so extra added channels will be shared among two view. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            417
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/5eb27c72fac25f6634e9c79d0a24735a1a738b8e428b8cb474fa9e027848f287.jpg",
+        "image_caption": [
+            "Figure 7: Linear evaluation of learned features when a few bits of competing features added (on MNIST). Adding a few bits completely disables contrastive learning (across various batch size or losses). Interestingly, it has little effects on a generative model (VAE). The detrimental effects are just as strong for larger datasets such as CIFAR-10 and ImageNet (Appendix B.1). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            428,
+            815,
+            574
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 7 shows the linear evaluation accuracy of models trained on MNIST (with additional random bits added). We observe that the linear evaluation accuracy quickly drops with a few bits of competing feature added. This detrimental effect on the representation quality persists on bigger datasets like CIFAR-10 and ImageNet as well, and cannot be avoided by using different contrastive losses, batch sizes, or memory mechanism based on momentum contrast (details in Appendix B.1). We believe the fact that just a few bits of easy-to-learn features can completely disable the good representation learning is related to the saturation of the distribution matching loss. As shown in Appendix B.2, the linear increase in bits requires an exponential increase in batch size, which is not sustainable as the required batch size can quickly go beyond the size of the dataset size. In practice, we rely on using data augmentation to remove those uninformative easy-to-learn features so that contrastive learning can learn useful representations. Interestingly, the extra bits do not affect a generative model, variational autoencoder [24, 25], nearly as much, despite other settings such as model size are held the same, prompting a potential direction of addressing the issue. ",
+        "bbox": [
+            173,
+            654,
+            825,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            852,
+            321,
+            869
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our work studies the contrastive loss based on cross entropy loss [15, 3, 4, 13]. This loss is widely used in recent successful contrastive learning methods [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]. In terms of the contrastive loss, our work is perhaps most related to [16], which shows that formulating contrastive loss as alignment and uniformity in the hypersphere gives similar performance as the standard contrastive loss. We further generalize this factorization, and show other distribution matching losses can be used, and they could achieve similar results. Other than standard contrastive loss that directly utilize negative examples, BYOL [22] demonstrates another way to maintain representation distribution/entropy without directly relying on distribution matching, and SWAV [26] shows clustering-based method equipped with proper data augmentations could also achieve similar performance. We conduct preliminary experiments of BYOL on RandBit and found that it also suffers from feature suppression as generalized contrastive loss. It is expected that SWAV would exhibit similar behaviors on RandBit as those random bits could fuel representations for perfect clustering. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            229
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The connection between contrastive loss and mutual information has been studied before [3, 20]. We show that for the generalized contrastive loss, it can also be related to mutual information. Despite the connection between contrastive loss and mutual information, it has been pointed out that mutual information estimation may suffer from certain limitations [27, 28]. Moreover, [29, 12] show that higher mutual information learned by the network does not warrant better representation quality. In our work, we find adding mutual information bits between two views which are irrelevant to downstream tasks can be harmful for the quality of learned representations. Data augmentation plays an important role at favoring certain bits of mutual information than others. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            347
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "There is a growing number of recent work on the topic of understanding contrastive learning, both theoretically [30, 31, 32, 33, 34] and empirically [16, 12, 35, 36]. However, little work has been done to study the phenomenon of feature suppression. To our knowledge, we are the first one to quantitatively and systematically study this problem. We believe this is still a very open question and could benefit from more future investigation. Finally, the feature suppression effect in unsupervised contrastive learning that we study in this work may also exist in standard supervised learning (“contrastive loss” between examples and class labels), as suggested by [37, 38], though the specific form would be different. ",
+        "bbox": [
+            174,
+            353,
+            825,
+            463
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            483,
+            299,
+            500
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we study three intriguing properties of contrastive losses. In particular, our results highlight that feature suppression is still an open challenge in contrastive learning. While there is a plethora of work on improving contrastive learning, few of them directly aim to address feature suppression. This limitation of contrastive learning becomes a bottleneck for scenarios where existing augmentation cannot fully address the feature suppression phenomenon, and learning would saturate at a level of dissatisfaction. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            597
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We would also like to point out some limitations of our study. Firstly, we focus mostly on contrastive learning with explicit negatives (e.g. SimCLR and MoCo). We believe other methods based on clustering and/or without negative pairs would exhibit similar phenomenon but we leave that as future work. Secondly, many of our proposed image datasets are not fully realistic despite being composed from some (challenging) natural image datasets such as ImageNet. We admit it is very hard to explore competing features or multiple objects in a controllable fashion on realistic large scale image datasets. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            688
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            707,
+            338,
+            723
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We specially thank Geoffrey Hinton for many inspiring discussions and helpful advice. We would also like to thank David Fleet, Simon Kornblith, Mohammad Norouzi, Kevin Swersky and Katherine Hermann for insightful discussions. In addition, we are thankful to William Chan and Sara Sabour for ideas on implementation of sorting on TPUs. We also thank the anonymous reviewers for their constructive feedback. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            808
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Suzanna Becker and Geoffrey E Hinton. Self-organizing neural network that discovers surfaces in randomdot stereograms. Nature, 355(6356):161–163, 1992.   \n[2] Alexey Dosovitskiy, Jost Tobias Springenberg, Martin Riedmiller, and Thomas Brox. Discriminative unsupervised feature learning with convolutional neural networks. In Advances in neural information processing systems, pages 766–774, 2014.   \n[3] Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.   \n[4] Zhirong Wu, Yuanjun Xiong, Stella X Yu, and Dahua Lin. Unsupervised feature learning via nonparametric instance discrimination. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3733–3742, 2018.   \n[5] R Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Phil Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. arXiv preprint arXiv:1808.06670, 2018.   \n[6] Philip Bachman, R Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. In Advances in Neural Information Processing Systems, pages 15509–15519, 2019.   \n[7] Olivier J Hénaff, Ali Razavi, Carl Doersch, SM Eslami, and Aaron van den Oord. Data-efficient image recognition with contrastive predictive coding. arXiv preprint arXiv:1905.09272, 2019.   \n[8] Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. arXiv preprint arXiv:1906.05849, 2019.   \n[9] Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representations. arXiv preprint arXiv:1912.01991, 2019.   \n[10] Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. arXiv preprint arXiv:1911.05722, 2019.   \n[11] Junnan Li, Pan Zhou, Caiming Xiong, Richard Socher, and Steven CH Hoi. Prototypical contrastive learning of unsupervised representations. arXiv preprint arXiv:2005.04966, 2020.   \n[12] Yonglong Tian, Chen Sun, Ben Poole, Dilip Krishnan, Cordelia Schmid, and Phillip Isola. What makes for good views for contrastive learning. arXiv preprint arXiv:2005.10243, 2020.   \n[13] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. arXiv preprint arXiv:2002.05709, 2020.   \n[14] Ting Chen, Simon Kornblith, Kevin Swersky, Mohammad Norouzi, and Geoffrey Hinton. Big selfsupervised models are strong semi-supervised learners. arXiv preprint arXiv:2006.10029, 2020.   \n[15] Kihyuk Sohn. Improved deep metric learning with multi-class n-pair loss objective. In Advances in neural information processing systems, pages 1857–1865, 2016.   \n[16] Tongzhou Wang and Phillip Isola. Understanding contrastive representation learning through alignment and uniformity on the hypersphere. arXiv preprint arXiv:2005.10242, 2020.   \n[17] Julien Rabin, Gabriel Peyré, Julie Delon, and Marc Bernot. Wasserstein barycenter and its application to texture mixing. In International Conference on Scale Space and Variational Methods in Computer Vision, pages 435–446. Springer, 2011.   \n[18] Nicolas Bonneel, Julien Rabin, Gabriel Peyré, and Hanspeter Pfister. Sliced and radon wasserstein barycenters of measures. Journal of Mathematical Imaging and Vision, 51(1):22–45, 2015.   \n[19] Soheil Kolouri, Kimia Nadjahi, Umut Simsekli, Roland Badeau, and Gustavo Rohde. Generalized sliced wasserstein distances. In Advances in Neural Information Processing Systems, pages 261–272, 2019.   \n[20] Ben Poole, Sherjil Ozair, Aaron van den Oord, Alexander A Alemi, and George Tucker. On variational bounds of mutual information. arXiv preprint arXiv:1905.06922, 2019.   \n[21] Yang You, Igor Gitman, and Boris Ginsburg. Large batch training of convolutional networks. arXiv preprint arXiv:1708.03888, 2017.   \n[22] Jean-Bastien Grill, Florian Strub, Florent Altché, Corentin Tallec, Pierre H. Richemond, Elena Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, Bilal Piot, Koray Kavukcuoglu, Rémi Munos, and Michal Valko. Bootstrap your own latent: A new approach to selfsupervised learning, 2020.   \n[23] 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.   \n[24] Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.   \n[25] Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. arXiv preprint arXiv:1401.4082, 2014.   \n[26] Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments. arXiv preprint arXiv:2006.09882, 2020.   \n[27] David McAllester and Karl Stratos. Formal limitations on the measurement of mutual information. In International Conference on Artificial Intelligence and Statistics, pages 875–884, 2020.   \n[28] Jiaming Song and Stefano Ermon. Understanding the limitations of variational mutual information estimators. arXiv preprint arXiv:1910.06222, 2019.   \n[29] Michael Tschannen, Josip Djolonga, Paul K Rubenstein, Sylvain Gelly, and Mario Lucic. On mutual information maximization for representation learning. arXiv preprint arXiv:1907.13625, 2019.   \n[30] Sanjeev Arora, Hrishikesh Khandeparkar, Mikhail Khodak, Orestis Plevrakis, and Nikunj Saunshi. A theoretical analysis of contrastive unsupervised representation learning. arXiv preprint arXiv:1902.09229, 2019.   \n[31] Yao-Hung Hubert Tsai, Yue Wu, Ruslan Salakhutdinov, and Louis-Philippe Morency. Demystifying self-supervised learning: An information-theoretical framework. arXiv preprint arXiv:2006.05576, 2020.   \n[32] Christopher Tosh, Akshay Krishnamurthy, and Daniel Hsu. Contrastive learning, multi-view redundancy, and linear models. arXiv preprint arXiv:2008.10150, 2020.   \n[33] Yuandong Tian, Lantao Yu, Xinlei Chen, and Surya Ganguli. Understanding self-supervised learning with dual deep networks. arXiv preprint arXiv:2010.00578, 2020.   \n[34] Jason D Lee, Qi Lei, Nikunj Saunshi, and Jiacheng Zhuo. Predicting what you already know helps: Provable self-supervised learning. arXiv preprint arXiv:2008.01064, 2020.   \n[35] Nanxuan Zhao, Zhirong Wu, Rynson WH Lau, and Stephen Lin. What makes instance discrimination good for transfer learning? arXiv preprint arXiv:2006.06606, 2020.   \n[36] Senthil Purushwalkam and Abhinav Gupta. Demystifying contrastive self-supervised learning: Invariances, augmentations and dataset biases. arXiv preprint arXiv:2007.13916, 2020.   \n[37] Katherine L Hermann and Andrew K Lampinen. What shapes feature representations? exploring datasets, architectures, and training. arXiv preprint arXiv:2006.12433, 2020.   \n[38] Harshay Shah, Kaustav Tamuly, Aditi Raghunathan, Prateek Jain, and Praneeth Netrapalli. The pitfalls of simplicity bias in neural networks. arXiv preprint arXiv:2006.07710, 2020.   \n[39] 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, pages 770–778, 2016. ",
+        "bbox": [
+            171,
+            85,
+            828,
+            912
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            89,
+            828,
+            602
+        ],
+        "page_idx": 11
+    }
+]