Add files using upload-large-folder tool

parse/train/3qMwV98zLIk/3qMwV98zLIk.md

@@ -0,0 +1,284 @@
+# FlexMatch: Boosting Semi-Supervised Learning with Curriculum Pseudo Labeling
+
+Bowen Zhang∗ Tokyo Institute of Technology bowen.z.ab@m.titech.ac.jp
+
+Yidong Wang∗ Tokyo Institute of Technology wang.y.ca@m.titech.ac.jp
+
+Wenxin Hou Microsoft wenxinhou@microsoft.com
+
+Hao Wu Tokyo Institute of Technology wu.h.aj@m.titech.ac.jp
+
+Jindong Wang† Microsoft Research Asia jindwang@microsoft.com
+
+Manabu Okumura† Tokyo Institute of Technology oku@pi.titech.ac.jp
+
+Takahiro Shinozaki† Tokyo Institute of Technology shinot@ict.e.titech.ac.jp
+
+# Abstract
+
+The recently proposed FixMatch achieved state-of-the-art results on most semisupervised learning (SSL) benchmarks. However, like other modern SSL algorithms, FixMatch uses a pre-defined constant threshold for all classes to select unlabeled data that contribute to the training, thus failing to consider different learning status and learning difficulties of different classes. To address this issue, we propose Curriculum Pseudo Labeling (CPL), a curriculum learning approach to leverage unlabeled data according to the model’s learning status. The core of CPL is to flexibly adjust thresholds for different classes at each time step to let pass informative unlabeled data and their pseudo labels. CPL does not introduce additional parameters or computations (forward or backward propagation). We apply CPL to FixMatch and call our improved algorithm FlexMatch. FlexMatch achieves state-of-the-art performance on a variety of SSL benchmarks, with especially strong performances when the labeled data are extremely limited or when the task is challenging. For example, FlexMatch achieves $1 3 . 9 6 \%$ and $1 8 . 9 6 \%$ error rate reduction over FixMatch on CIFAR-100 and STL-10 datasets respectively, when there are only 4 labels per class. CPL also significantly boosts the convergence speed, e.g., FlexMatch can use only 1/5 training time of FixMatch to achieve even better performance. Furthermore, we show that CPL can be easily adapted to other SSL algorithms and remarkably improve their performances. We open-source our code at https://github.com/TorchSSL/TorchSSL.
+
+# 1 Introduction
+
+Semi-supervised learning (SSL) has attracted increasing attention in recent years due to its superiority in leveraging a large amount of unlabeled data. This is particularly advantageous when the labeled data are limited in quantity or laborious to obtain. Consistency regularization [1–3] and pseudo labeling [4–8] are two powerful techniques for utilizing unlabeled data and have been widely used in modern SSL algorithms [9–13]. The recently proposed FixMatch [14] achieves competitive results by combining these techniques with weak and strong data augmentations and using cross-entropy loss as the consistency regularization criterion.
+
+However, a drawback of FixMatch and other popular SSL algorithms such as Pseudo-Labeling [4] and Unsupervised Data Augmentation (UDA) [11] is that they rely on a fixed threshold to compute the unsupervised loss, using only unlabeled data whose prediction confidence is above the threshold. While this strategy can make sure that only high-quality unlabeled data contribute to the model training, it ignores a considerable amount of other unlabeled data, especially at the early stage of the training process, where only a few unlabeled data have their prediction confidence above the threshold. Moreover, modern SSL algorithms handle all classes equally without considering their different learning difficulties.
+
+To address these issues, we propose Curriculum Pseudo Labeling (CPL), a curriculum learning [15] strategy to take into account the learning status of each class for semi-supervised learning. CPL substitutes the pre-defined thresholds with flexible thresholds that are dynamically adjusted for each class according to the current learning status. Notably, this process does not introduce any additional parameter (hyper-parameter or trainable parameter) or extra computation (forward or back propagation). We apply this curriculum learning strategy directly to FixMatch and call the improved algorithm FlexMatch.
+
+While the training speed remains as efficient as that of FixMatch, FlexMatch converges significantly faster and achieves state-of-the-art performances on most SSL image classification benchmarks. The benefit of introducing CPL is particularly remarkable when the labels are scarce or when the task is challenging. For instance, on the STL-10 dataset, FlexMatch achieves relative performance improvement over FixMatch by $1 8 . 9 6 \%$ , $1 6 . 1 1 \%$ , and $7 . 6 8 \%$ when the label amount is 400, 2500, and 10000 respectively. Moreover, CPL further shows its superiority by boosting the convergence speed – with CPL, FlexMatch takes less than 1/5 training time of FixMatch to reach its final accuracy. Adapting CPL to other modern SSL algorithms also leads to improvements in accuracy and convergence speed.
+
+To sum up, this paper makes the following three contributions:
+
+• We propose Curriculum Pseudo Labeling (CPL), a curriculum learning approach of dynamically leveraging unlabeled data for SSL. It is almost cost-free and can be easily integrated to other SSL methods.   
+• CPL significantly boosts the accuracy and convergence performance of several popular SSL algorithms on common benchmarks. Specifically, FlexMatch, the integration of FixMatch and CPL, achieves state-of-the-art results.   
+• We open-source TorchSSL, a unified PyTorch-based semi-supervised learning codebase for the fair study of SSL algorithms. TorchSSL includes implementations of popular SSL algorithms and their corresponding training strategies, and is easy to use or customize.
+
+# 2 Background
+
+Consistency regularization follows the continuity assumption of SSL [1, 2]. The most basic consistency loss in SSL, such as in $\Pi$ Model [9], Mean Teacher [10] and MixMatch [12], is the ℓ-2 loss:
+
+$$
+\sum _ { b = 1 } ^ { \mu B } | | p _ { m } ( y | \omega ( u _ { b } ) ) - p _ { m } ( y | \omega ( u _ { b } ) ) | | _ { 2 } ^ { 2 } ,
+$$
+
+where $B$ is the batch size of labeled data, $\mu$ is the ratio of unlabeled data to labeled data, $\omega$ is a stochastic data augmentation function (thus the two terms in Eq.(1) are different), $u _ { b }$ denotes a piece of unlabeled data, and $p _ { m }$ represents the output probability of the model. With the introduction of pseudo labeling techniques [5, 7], the consistency regularization is converted to an entropy minimization process [16], which is more suitable for the classification task. The improved consistency loss with pseudo labeling can be represented as:
+
+$$
+\frac { 1 } { \mu B } \sum _ { b = 1 } ^ { \mu B } \mathbb { 1 } ( \operatorname* { m a x } ( p _ { m } ( y | \omega ( u _ { b } ) ) ) > \tau ) H ( \hat { p } _ { m } ( y | \omega ( u _ { b } ) ) , p _ { m } ( y | \omega ( u _ { b } ) ) ) ,
+$$
+
+![](images/4268f791afd62be454ac4961a9143bcfb993683de92a9af07eca9c581cd26eb4.jpg)  
+Figure 1: Illustration of Curriculum Pseudo Label (CPL). The estimated learning effects of each class are decided by the number of unlabeled data samples falling into this class and above the fixed threshold. They are then used to adjust the flexible thresholds to let pass the optimal unlabeled data. Note that the estimated learning effects do not always grow – they may also decrease if the predictions of the unlabeled data fall into other classes in later iterations.
+
+where $H$ is cross-entropy, $\tau$ is the pre-defined threshold and $\hat { p } _ { m } ( y | \omega ( u _ { b } ) )$ is the pseudo label that can either be a ‘hard’ one-hot label [4, 14] or a sharpened ‘soft’ one [11]. The intention of using a threshold is to mask out noisy unlabeled data that have low prediction confidence.
+
+FixMatch utilizes such consistency regularization with strong augmentation to achieve competitive performance. For unlabeled data, FixMatch first uses weak augmentation to generate artificial labels. These labels are then used as the target of strongly-augmented data. The unsupervised loss term in FixMatch thereby has the form:
+
+$$
+\frac { 1 } { \mu B } \sum _ { b = 1 } ^ { \mu B } \mathbb { 1 } ( \operatorname* { m a x } ( p _ { m } ( y | \omega ( u _ { b } ) ) ) > \tau ) H ( \hat { p } _ { m } ( y | \omega ( u _ { b } ) ) , p _ { m } ( y | \Omega ( u _ { b } ) ) ) ,
+$$
+
+where $\Omega$ is a strong augmentation function instead of weak augmentation $\omega$ .
+
+Of the aforementioned works, the pre-defined threshold $( \tau )$ is constant. We believe this can be improved because the data of some classes may be inherently more difficult to learn than others. Curriculum learning [15] is a learning strategy where learning samples are gradually introduced according to the model’s learning process. In such a way, the model is always optimally challenged. This technique is widely employed in deep learning research [17–21].
+
+# 3 FlexMatch
+
+# 3.1 Curriculum Pseudo Labeling
+
+While current SSL algorithms render pseudo labels of only high-confidence unlabeled data cut off by a pre-defined threshold, CPL renders the pseudo labels to different classes and at different time steps. Such a process is realized by adjusting the thresholds according to the model’s learning status of each class.
+
+However, it is non-trivial to dynamically determine the thresholds according to the learning status. The most ideal approach would be calculating evaluation accuracies for each class and use them to scale the threshold, as:
+
+$$
+T _ { t } ( c ) = a _ { t } ( c ) \cdot \tau ,
+$$
+
+where $\mathcal { T } _ { t } ( c )$ is the flexible threshold for class $c$ at time step $t$ and $a _ { t } ( c )$ is the corresponding evaluation accuracy. In this way, lower accuracy that indicates a less satisfactory learning status of the class will lead to a lower threshold that encourages more samples of this class to be learned. Since we cannot use the evaluation set in the model learning process, one may have to separate an extra validation set from the training set for such accuracy evaluations. However, this practice show two fatal problems: First, such a labeled validation set separated from the training set is expensive under SSL scenario as the labeled data are already scarce. Second, to dynamically adjust the thresholds in the training process, accuracy evaluations must be done continually at each time step $t$ , which will considerably slow down the training speed.
+
+In this work, we propose Curriculum Pseudo Labeling (CPL) for semi-supervised learning. Our CPL uses an alternative way to estimate the learning status, which does not introduce additional inference processes, nor needs an extra validation set. As believed in [14], a high threshold that filters out noisy pseudo labels and leaves only high-quality ones can considerably reduce the confirmation bias [22]. Therefore, our key assumption is that when the threshold is high, the learning effect of a class can be reflected by the number of samples whose predictions fall into this class and above the threshold. Namely, the class with fewer samples having their prediction confidence reach the threshold is considered to have a greater learning difficulty or a worse learning status, formulated as:
+
+$$
+\sigma _ { t } ( c ) = \sum _ { n = 1 } ^ { N } \mathbb { 1 } ( \operatorname* { m a x } ( p _ { m , t } ( y | u _ { n } ) ) > \tau ) \cdot \mathbb { 1 } ( \arg \operatorname* { m a x } ( p _ { m , t } ( y | u _ { n } ) = c ) .
+$$
+
+where $\sigma _ { t } ( c )$ reflects the learning effect of class $c$ at time step $t$ . $p _ { m , t } ( y | u _ { n } )$ is the model’s prediction for unlabeled data $u _ { n }$ at time step $t$ , and $N$ is the total number of unlabeled data. When the unlabeled dataset is balanced (i.e., the number of unlabeled data belonging to different classes are equal or close), larger $\sigma _ { t } ( c )$ indicates a better estimated learning effect. By applying the following normalization to $\sigma _ { t } ( c )$ to make its range between 0 to 1, it can then be used to scale the fixed threshold $\tau$ :
+
+$$
+\beta _ { t } ( c ) = \frac { \sigma _ { t } ( c ) } { \operatorname* { m a x } _ { c } \sigma _ { t } } ,
+$$
+
+$$
+\begin{array} { r } { \mathcal { T } _ { t } ( c ) = \beta _ { t } ( c ) \cdot \tau . } \end{array}
+$$
+
+One characteristic of such a normalization approach is that the best-learned class has its $\beta _ { t } ( c )$ equal to 1, causing its flexible threshold equal to $\tau$ . This is desirable. For classes that are hard to learn, the thresholds are lowered down, encouraging more training samples in these classes to be learned. This also improves the data utilization ratio. As learning proceeds, the threshold of a well-learned class is raised higher to selectively pick up higher-quality samples. Eventually, when all classes have reached reliable accuracies, the thresholds will all approach $\tau$ . Note that the thresholds do not always grow, it may also decrease if the unlabeled data is classified into a different class in later iterations. This new threshold is used for calculating the unsupervised loss in FlexMatch, which can be formulated as:
+
+$$
+\mathcal { L } _ { u , t } = \frac { 1 } { \mu B } \sum _ { b = 1 } ^ { \mu B } \mathbb { 1 } ( \operatorname* { m a x } ( q _ { b } ) > \mathcal { T } _ { t } ( \arg \operatorname* { m a x } ( q _ { b } ) ) ) H ( \hat { q } _ { b } , p _ { m } ( y | \Omega ( u _ { b } ) ) ) ,
+$$
+
+where $q _ { b } = p _ { m } ( y | \omega ( u _ { b } ) )$ . The flexible thresholds are updated at each iteration. Finally, we can formulate the loss in FlexMatch as the weighted combination (by $\lambda$ ) of supervised and unsupervised loss:
+
+$$
+\begin{array} { r } { \mathcal { L } _ { t } = \mathcal { L } _ { s } + \lambda \mathcal { L } _ { u , t } , } \end{array}
+$$
+
+where $\mathcal { L } _ { s }$ is the supervised loss on labeled data:
+
+$$
+\mathcal { L } _ { s } = \frac { 1 } { B } \sum _ { b = 1 } ^ { B } H \big ( y _ { b } , p _ { m } ( y | \omega ( x _ { b } ) ) \big ) .
+$$
+
+Note that the cost of introducing CPL is almost free. Practically, every time the prediction confidence of an unlabeled data $u _ { n }$ is above the fixed threshold $\tau$ , the data, and its predicted class are marked and will be used for calculating $\beta _ { t } ( c )$ at the next time step. Such marking actions are bonus actions each time the consistency loss is computed. Therefore, FlexMatch does not introduce additional forward propagation processes for evaluating the model’s learning status, nor new parameters.
+
+# 3.2 Threshold warm-up
+
+We noticed in our experiments that at the early stage of the training, the model may blindly predict most unlabeled samples into a certain class depending on the parameter initialization(i.e., more likely to have confirmation bias). Hence, the estimated learning status may not be reliable at this stage. Therefore, we introduce a warm-up process by rewriting the denominator in Eq. (6) as:
+
+$$
+\beta _ { t } ( c ) = \frac { \sigma _ { t } ( c ) } { \operatorname* { m a x } \left\{ \operatorname* { m a x } _ { c } \sigma _ { t } , N - \sum _ { c } \sigma _ { t } \right\} } ,
+$$
+
+1: Input: $\mathcal X = \{ ( x _ { m } , y _ { m } ) : m \in ( 1 , \ldots , M ) \} , \mathcal { U } = \{ u _ { n } : n \in ( 1 , \ldots , N ) \}$ {M labeled data and   
+N unlabeled data.}   
+2: $\hat { u } _ { n } = - 1 : n \in ( 1 , \dots , N )$ {Initialize predictions of all unlabeled data as $^ { - 1 }$ indicating unused.}   
+3: while not reach the maximum iteration do   
+4: for $c = 1$ to $C$ do   
+5: $\begin{array} { r } { \sigma ( c ) = \sum _ { n = 1 } ^ { N } \mathbb { 1 } ( \hat { u } _ { n } = c ) } \end{array}$ {Compute estimated learning effect.}   
+6: if max $\begin{array} { r } { \sigma ( c ) < \sum _ { n = 1 } ^ { N } \mathbb { 1 } ( \hat { u } _ { n } = - 1 ) } \end{array}$ then   
+7: Calculate $\beta ( c )$ using Eq. (11) {Threshold warms up when unused data dominate.}   
+8: else   
+9: Calculate $\beta ( c )$ using Eq. (6) {Compute normalized estimated learning effect.}   
+10: end if   
+11: Calculate $\tau ( c )$ using Eq. (7) {Determine the flexible threshold for class $c$ .}   
+12: end for   
+13: for $b = 1$ to $\mu B$ do   
+14: if $p _ { m } ( y | \omega ( u _ { b } ) ) > \tau$ then   
+15: $\hat { u } _ { b } = \arg \operatorname* { m a x } q _ { b }$ {Update the prediction of unlabeled data $u _ { b }$ .}   
+16: end if   
+17: end for   
+18: Compute the loss via Eq. (8), (10) and (9).   
+19: end while   
+20: Return: Model parameters.
+
+where the term $\begin{array} { r } { N - \sum _ { c = 1 } ^ { C } \sigma _ { t } ( c ) } \end{array}$ can be regarded as the number of unlabeled data that have not been used. This ensures that at the beginning of the training, all estimated learning effects gradually rise from 0 until the number of unused unlabeled data is no longer predominant. The duration of such a period depends on the unlabeled data amount (ref. $N$ in Eq. (11)) and the learning difficulty (ref. the growing speed of $\sigma _ { t } ( c )$ in Eq. (11)) of the dataset. In practice, such a warm-up process is very easy to implement as we can add an extra class to denote the unused unlabeled data. Thus calculating the denominator of Eq. (11) is simply converted to finding the maximum among $c + 1$ classes.
+
+# 3.3 Non-linear mapping function
+
+The flexible threshold in Eq. (7) is determined by the normalized estimated learning effects via a linear mapping. However, it may not be the most suitable mapping in the real training process, where the increase or decrease of $\beta _ { t } ( c )$ may make big jumps in the early phase where the predictions of the model are still unstable; and only make small fluctuations after the class is well-learned in the mid and late training stage. Therefore, it is preferable if the flexible thresholds can be more sensitive when $\beta _ { t } ( c )$ is large and vice versa.
+
+We propose a non-linear mapping function to enable the thresholds to have a non-linear increasing curve when $\beta _ { t } ( c )$ ranges uniformly from 0 to 1, as formulated below:
+
+$$
+\mathscr { T } _ { t } ( c ) = \mathcal { M } ( \beta _ { t } ( c ) ) \cdot \tau ,
+$$
+
+where $\mathcal { M } ( \cdot )$ is a non-linear mapping function. It is clear that Eq. (7) can be seen as a special case by setting $\mathcal { M }$ to the identity function. The mapping function $\mathcal { M }$ should be monotonically increasing and have a maximum no larger than $1 / \tau$ (otherwise the flexible threshold can be larger than 1 and filter out all samples). To avoid introducing additional hyper-parameters (e.g. lower limits of the flexible thresholds), we consider the mapping function to have a range from 0 to 1 so that the flexible thresholds range from 0 to $\tau$ .
+
+A monotone increasing convex function lets the thresholds grow slowly when $\beta _ { t } ( c )$ is small, and become more sensitive as $\beta _ { t } ( c )$ gets larger. Hence, we intuitively choose a convex function with the above-mentioned properties to compare among mapping $\begin{array} { r } { \mathcal { M } ( x ) = \frac { x } { 2 - x } } \end{array}$ for our experiments. We also conduct an ablation studyh different convexity and concavity in Sec. 4.4. The full algorithm of FlexMatch is shown in Algorithm 1.
+
+Table 1: Error rates on CIFAR-10/100, SVHN, and STL-10 datasets. The ‘Flex’ prefix denotes applying CPL to the algorithm, and ‘PL’ is an abbreviation of Pseudo-Labeling. STL-10 dataset does not have label information for unlabeled data, thus its fully-supervised result is unavailable.   
+
+<table><tr><td>Dataset</td><td colspan="3">CIFAR-10</td><td colspan="3">CIFAR-100</td><td colspan="3">STL-10</td><td colspan="2">SVHN</td></tr><tr><td>Label Amount</td><td>40</td><td>250</td><td>4000</td><td>400</td><td>2500</td><td>10000</td><td>40</td><td>250</td><td>1000</td><td>40</td><td>1000</td></tr><tr><td>PL</td><td>74.61±0.26</td><td>46.49±2.20</td><td>15.08±0.19</td><td>87.45±0.85</td><td>57.74±0.28</td><td>36.55±0.24</td><td>74.68±0.99</td><td>55.45±2.43</td><td>32.64±0.71</td><td>64.61±5.60</td><td>9.40±0.32</td></tr><tr><td>Flex-PL</td><td>73.74±1.96</td><td>46.14±1.81</td><td>14.75±0.19</td><td>85.72±0.46</td><td>56.12±0.51</td><td>35.60±0.15</td><td>73.42±2.19</td><td>52.06±2.50</td><td>32.05±0.37</td><td>63.21±3.64</td><td>12.05±0.54</td></tr><tr><td>UDA</td><td>10.62±3.75</td><td>5.16±0.06</td><td>4.29±0.07</td><td>46.39±1.59</td><td>27.73±0.21</td><td>22.49±0.23</td><td>37.42±8.44</td><td>9.72±1.15</td><td>6.64±0.17</td><td>5.12±4.27</td><td>1.89±0.01</td></tr><tr><td>Flex-UDA</td><td>5.44±0.52</td><td>5.02±0.07</td><td>4.24±0.06</td><td>45.17±1.88</td><td>27.08±0.15</td><td>21.91±0.10</td><td>29.53±2.10</td><td>9.03±0.45</td><td>6.10±0.25</td><td>3.42±1.51</td><td>2.02±0.05</td></tr><tr><td>FixMatch</td><td>7.47±0.28</td><td>4.86±0.05</td><td>4.21±0.08</td><td>46.42±0.82</td><td>28.03±0.16</td><td>22.20±0.12</td><td>35.97±4.14</td><td>9.81±1.04</td><td>6.25±0.33</td><td>3.81±1.18</td><td>1.96±0.03</td></tr><tr><td>FlexMatch</td><td>4.97±0.06</td><td>4.98±0.09</td><td>4.19±0.01</td><td>39.94±1.62</td><td>26.49±0.20</td><td>21.90±0.15</td><td>29.15 ±4.16</td><td>8.23±0.39</td><td>5.77±0.18</td><td>8.19±3.20</td><td>6.72±0.30</td></tr><tr><td>Fully-Supervised</td><td></td><td>4.62± 0.05</td><td></td><td></td><td>19.30± 0.09</td><td></td><td></td><td>：</td><td></td><td>2.13± 0.02</td><td></td></tr></table>
+
+# 4 Experiments
+
+We evaluate FlexMatch and other CPL-enabled algorithms on common SSL datasets: CIFAR10/100 [23], SVHN [24], STL-10 [25] and ImageNet [26], and extensively investigate the performance under various labeled data amounts. We mainly compare our method with Pseudo-Labeling [4], UDA [11] and FixMatch [14], since they all involve a pre-defined threshold. The results of other popular SSL algorithms are in the appendix. We also add a fully-supervised experiment for each dataset to better understand the results of SSL algorithms. Note that previously suggested [27] fully-supervised comparisons use only the labeled set for training, whose purpose is to manifest the improvement brought by the introduction of unlabeled data. With the development of modern SSL algorithms, however, semi-supervised approaches are achieving competitive performance with supervised ones, or even better performance due to the strength of consistency regularization. Therefore, our fully-supervised comparisons are conducted with all data labeled, and apply weak data augmentations following Eq. (10). We re-implement all baselines using our PyTorch [28] codebase: TorchSSL, which is introduced in the appendix.
+
+For a fair comparison, we use the same hyper-parameters following FixMatch [14]. Concretely, the optimizer for all experiments is standard stochastic gradient descent (SGD) with a momentum of 0.9 [29, 30]. For all datasets, we use an initial learning rate of 0.03 with a cosine learning rate decay schedule [31] as $\eta = \eta _ { 0 } \cos ( \frac { 7 \pi k } { 1 6 K } )$ , where $\eta _ { 0 }$ is the initial learning rate, $k$ is the current training step and $K$ is the total training step that is set to $2 ^ { 2 0 }$ . We also perform an exponential moving average with the momentum of 0.999. The batch size of labeled data is 64 except for ImageNet. $\mu$ is set to be 1 for Pseudo-Label and 7 for UDA, FixMatch, and FlexMatch. $\tau$ is set to 0.8 for UDA and 0.95 for Pseudo Label, FixMatch, and FlexMatch. These setups follow the original papers. The strong augmentation function used in our experiments is RandAugment [32]. We use ResNet-50 [33] for the ImageNet experiment and Wide ResNet (WRN) [34] and its variant [35] for other datasets. Detailed hyper-parameters are listed in the appendix.
+
+We adopt two evaluation metrics: (1) the median error rate of the last 20 checkpoints following [12, 14], and (2) the best error rate in all checkpoints. We argue that the median approach is not suitable when the convergence speeds of the algorithms show significant differences – the large number of redundant iterations may result in over-fitting for the fast-converge algorithms. Therefore, we report the best error rates for all algorithms, while the results of the median approach are also provided in the appendix, showing that our FlexMatch still achieves the best performance. We run each task three times using distinct random seeds to obtain the error bars.
+
+# 4.1 Main results
+
+The classification error rates on CIFAR-10/100, STL-10 and SVHN datasets are in Table 1, and the results on ImageNet are in Sec. 4.2. Note that the SVHN dataset used in our experiment also includes the extra set that contains 531,131 additional samples. Results demonstrate that FlexMatch achieves the state-of-the-art performance on most of the benchmark datasets except for SVHN where Flex-UDA (i.e., UDA with CPL) and UDA have the lowest error rate on the 40-label split and the 1000-label split, respectively. We also provide the detailed precision, recall, F1, and AUC results in the appendix. Our CPL (FlexMatch) has the following advantages:
+
+CPL achieves better performance on tasks with extremely limited labeled data. Our FlexMatch significantly outperforms other methods when the amount of labels is extremely small. For instance, on the CIFAR-100 dataset with 400 labels (i.e., only 4 label samples per class), FlexMatch achieves an average error rate of $3 9 . 9 4 \%$ , which significantly outperforms FixMatch $( 4 6 . 4 2 \% )$ .
+
+![](images/95e0b0a2acc75c03a3ed45c4def27cd321c39eeea99d0163596dd74ef0d7f61c.jpg)  
+Figure 3: Convergence analysis of FixMatch and FlexMatch. (a) and (b) depict the loss and top1-accuracy on CIFAR-100 with 400 labels. Evaluations are done every 5K iterations. (c) and (d) demonstrate the class-wise accuracy within the first 200K iterations on CIFAR-10 dataset. The numbers in legend correspond to the ten classes in the dataset.
+
+CPL improves the performance of existing SSL algorithms. Other than FixMatch, CPL can also improve the performance of other existing SSL algorithms such as Pseudo-Labeling and UDA. For instance, the error rate is reduced from $3 7 . 4 \%$ to $2 9 . 5 3 \%$ for UDA on the STL-10 40-label split after introducing CPL (refer to as Flex-UDA in Table 1). These results further prove the effectiveness of CPL in better leveraging unlabeled data. Figure 2 shows the average running time of a single iteration with or without adding our CPL, it is clear that while improving the performance of existing SSL algorithms, our CPL does not introduce additional computational burden.
+
+![](images/267f4b68f8f3b6cde9f37de6e95bc2454642fe2c44002364f1a0348fc5674f32.jpg)  
+Figure 2: Average running time of one iteration on a single GeForce RTX 3090 GPU.
+
+CPL achieves better performance on complicated tasks. The STL-10 dataset contains unlabeled data from a similar but broader distribution of images than its labeled set. The existence of new types of objects in the unlabeled dataset makes STL-10 a more challenging and realistic task. FlexMatch achieves greater performance improvement under such a challenging situation. The error rate on STL-10 with only 40 labels is $2 9 . 1 5 \%$ , which is relatively $1 8 . 9 6 \%$ better than FixMatch $( 3 5 . 9 7 \% )$ . Similar strong improvements are also observed on CIFAR-100 dataset, which has as many as one hundred classes.
+
+We also analyze the reason why FlexMatch performs less favorably on SVHN. This is probably because SVHN is a relatively simple (i.e., to classify digits) yet unbalanced dataset. The class-wise imbalance leads to the classes with fewer samples never have their estimated learning effects close to 1 according to Eq. (6), even when they are already well-learned. Such low thresholds allow noisy pseudo-labeled samples to be trusted and learned throughout the training process, which is also reflected by the loss descent curve where the low-threshold classes have major fluctuations. FixMatch, on the other hand, fixes its threshold at 0.95 to filter out noisy samples. Such a fixed high threshold is not preferable with respect to both accuracies of hard-to-learn classes and overall convergence speed as explained earlier, but since SVHN is an easy task, the model can easily learn the task and make high-confidence predictions, setting a high-fixed threshold thus becomes less problematic and has its advantages overweighed.
+
+# 4.2 Results on ImageNet
+
+We also verify the effectiveness of CPL on ImageNet-1K [26] which is a much more realistic and complicated dataset. We randomly choose the same 100K labeled data (i.e., 100 labels per class), which is less than $8 \%$ of the total labels. The hyper-parameters used for ImageNet can be found in the appendix, where the two algorithms share the same hyper-parameters. We show the error rate comparison after running $2 ^ { 2 0 }$ iterations in Table 2. This result indicates that when the task is complicated, despite the class imbalance issue (the number of images within each class ranges from 732 to 1300), CPL can still bring improvements. Note that this result does not represent the best performance of each algorithm as the model cannot fully converge after $2 ^ { 2 0 }$ iterations, and due to the computational resource limitation, we did not further tune the hyper-parameters to obtain the best results on ImageNet.
+
+Table 2: Error rate results on ImageNet after $2 ^ { 2 0 }$ iterations.   
+
+<table><tr><td>Method</td><td>Top-1</td><td>Top-5</td></tr><tr><td>FixMatch FlexMatch</td><td>43.66 42.02</td><td>21.80 19.49</td></tr></table>
+
+![](images/5151884492ed3cfe65eefa496339c009a476cb6955e2bded3395e9a33e4cc977.jpg)  
+Figure 4: Ablation study of FlexMatch.
+
+# 4.3 Convergence speed acceleration
+
+Another strong advantage of FlexMatch is its superior convergence speed. Figure 3(a) and 3(b) shows the comparison between FlexMatch and FixMatch with respect to the loss and top-1-accuracy on CIFAR-100 400-label split. The loss of FlexMatch decreases much faster and smoother than FixMatch, demonstrating its superior convergence speed. The major fluctuations of the loss in FixMatch may due to the pre-defined threshold that lets pass most unlabeled data belonging to certain classes, whereas with CPL a larger batch of unlabeled data containing samples from various classes enables the gradient to more directly head toward the global optimum. As a result, with only 50K iterations, FlexMatch has already surpassed the final results of FixMatch. After 800K iterations, however, we observe a further decrease in loss and accuracy. This is likely due to over-fitting, which also occurs in FixMatch after 900K iterations. Thus, we believe it is not fair to use the median results of the last few checkpoints for evaluating algorithms with different convergence speeds.
+
+We further compare the class-wise accuracy of FixMatch and FlexMatch on CIFAR-10 in their early training stages. As shown in Figure 3(c) and 3(d), at iteration 200K, FixMatch only hits an overall accuracy of $5 6 . 3 5 \%$ as half of the classes are still learned unsatisfactorily, whereas FlexMatch has already achieved an overall accuracy of $9 4 . 2 9 \%$ which is even higher than the final accuracy reached by FixMatch after 1M iterations. It is manifest that the introduction of CPL successfully encourages the model to proactively learn those difficult classes thereby improving the overall learning effect.
+
+# 4.4 Ablation study
+
+We conduct experiments to evaluate three components of FlexMatch: the upper limit of thresholds $\tau$ mapping functions $\mathcal M ( x )$ , and threshold warm-up.
+
+Threshold upper bound. We investigate 5 different $\tau$ values and 3 different mapping functions on CIFAR-10 dataset with 40 labels. As shown in Figure 4(a), the optimal choice of $\tau$ is around 0.95, either increasing or decreasing this value results in a performance decay. Note that in FlexMatch, tuning $\tau$ does not only affect the upper limit of the threshold but also the estimated learning effects because they are determined by the number of samples that fall above $\tau$ .
+
+Mapping function. We explore three different mapping functions in Figure 4(b): (1) concave: $\mathcal { M } ( x ) = \ln ( x + 1 ) / \ln 2$ , (2) linear: $\mathcal { M } ( x ) = x$ , and (3) convex: $\mathcal { M } ( x ) = x / ( 2 - x )$ . We see that the convex function shows the best performance and the concave function shows the worst. Although tweaking the degree of convexity may probably lead to further improvement, we do not make further investigation in this paper. It is noteworthy that all these functions have their outputs grow from 0 to 1 when the inputs go from 0 to 1. One may also design a function with a different range, for instance, from 0.5 to 1. In this case, it is equivalent to setting a lower limit to the flexible threshold so that even at the beginning of the training, only samples with prediction confidence higher than this limit will contribute to the unsupervised loss. We do not include such a lower limit in FlexMatch since it will introduce a new hyper-parameter. However, we did find that setting a lower limit at 0.5 can slightly improve the performance. A possible reason is that the lower threshold prevents noisy training caused by incorrect pseudo labels at the early stage [36].
+
+Threshold warm-up. We analyze the performance of threshold warm-up on both CIFAR-10 (40 labels) and CIFAR-100 (400 labels) datasets. As shown in Figure 4(c), threshold warm-up can bring about $0 . 2 \%$ absolute improvement on CIFAR-10 and about $1 \%$ on CIFAR-100. At the beginning of the training without the threshold warm-up, the flexible thresholds may go through heavy fluctuations because the denominator in Eq.(6) is small. In the meantime, there will always be some classes whose flexible thresholds reach or approach $\tau$ , thereby filtering out most unlabeled data in the batch. The threshold warm-up solves this issue by gradually raising the thresholds of all classes from zero – it creates a learning boom at the early training stage where most of the unlabeled data can be utilized.
+
+Comparison with class balancing objectives. CPL has the effect of balancing across classes the number of unlabeled samples used to compute pseudo-labeling loss in each batch. Similar effect can be achieved by making the marginal class distribution close to a uniform distribution for each batch. We conduct such a comparative experiment by directly adding an additional objective to FixMatch: $\begin{array} { r } { \mathcal { L } _ { b } = \sum _ { c } q _ { c } \log ( q _ { c } / \hat { p } _ { c } ) } \end{array}$ [22], where $\hat { p } _ { c }$ is the mean predicted probability of class $c$ across all samples in the batch, and $q$ is a uniform distribution: $q _ { c } = 1 / C$ . The error rate of adding such an objective is $7 . 1 6 \%$ on the CIFAR-10 40-label split (compared with FixMatch $7 . 4 7 \% \pm 0 . 2 8$ and FlexMatch $4 . 9 7 \% \pm 0 . 0 6 )$ . While this approach requires instances of each class within each batch to be balanced to make sense, CPL does not have such a constraint. It is more flexible and involves less human intervention to adjust thresholds than adjusting model’s predictions.
+
+# 5 Related Work
+
+Pseudo-Labeling [4] is a pioneer SSL method that uses hard artificial labels converted from model predictions. A confidence-based strategy was used in [6] along with pseudo labeling so that the unlabeled data are used only when the predictions are sufficiently confident. Such confidence-based thresholding also presents in recently proposed UDA [11] and FixMatch [14] with the difference being that UDA used sharpened ‘soft’ pseudo labels with a temperature whereas Fixmatch adopted one-hot ‘hard’ labels. The success of UDA and FixMatch, however, relies heavily on the usage of strong data augmentations to improve the consistency regularization. ReMixMatch [13] also leveraged such strong augmentations.
+
+The combination of curriculum learning and semi-supervised learning is popular in recent years [37– 39]. For multi-model image classification task, [37] optimized the learning process of unlabeled images by judging their reliability and discriminability. In [38], the easy image-level properties are learned first and then used to facilitate segmentation via constrained CNNs. Curriculum learning is also used to alleviate out-of-distribution problems by picking up in-distribution samples from unlabeled data according to the out-of-distribution scores [39].
+
+Several researches have investigated on dynamic threshold in related fields such as sentiment analysis [40] and semantic segmentation [41]. In [40], the threshold was gradually reduced to make high-quality data selected into labeled data set in the early stage and large-quantity in the later stage. An extra classifier is added to automate the threshold to deal with domain inconsistency in [41]. [42] introduced curriculum learning to self-training with a steadily increasing threshold and achieved near state-of-the-art results.
+
+# 6 Conclusion and Future Work
+
+In this paper, we introduce Curriculum Pseudo Labeling (CPL), a curriculum learning approach of leveraging unlabeled data for SSL. CPL dramatically improves the performance and convergence speed of SSL algorithms that involve thresholds while being extremely simple and almost cost-free. FlexMatch, our improved algorithm of FixMatch, achieves state-of-the-art performance on a variety of SSL benchmarks. In future work, we would like to improve our method under the long-tail scenario where the unlabeled data belonging to each class are extremely unbalanced.
+
+# Broader Impact
+
+CPL fills the gap that no modern SSL algorithm considers the inherent learning difficulties of different classes during the training, and shows that by doing so, the convergence speed and final accuracy can both be improved. We hope that CPL can attract more future attention to explore the effectiveness of utilizing unlabeled data according to the model’s learning status as well as the per-class learning difficulty.
+
+# Funding Disclosure
+
+Funding in direct support of this work: computing resource granted by Tokyo Institute of Technology and Microsoft Research Asia. This work was partially supported by Toray Science Foundation.
+
+# References
+
+[1] Philip Bachman, Ouais Alsharif, and Doina Precup. Learning with pseudo-ensembles. In NeurIPS, pages 3365–3373, 2014.   
+[2] Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. ICLR, 2017.   
+[3] Mehdi Sajjadi, Mehran Javanmardi, and Tolga Tasdizen. Regularization with stochastic transformations and perturbations for deep semi-supervised learning. In NeurIPS, pages 1171–1179, 2016.   
+[4] Dong-Hyun Lee et al. Pseudo-label: The simple and efficient semi-supervised learning method for deep neural networks. In Workshop on challenges in representation learning, ICML, volume 3, 2013.   
+[5] Geoffrey J McLachlan. Iterative reclassification procedure for constructing an asymptotically optimal rule of allocation in discriminant analysis. Journal of the American Statistical Association, 70(350):365–369, 1975.   
+[6] Chuck Rosenberg, Martial Hebert, and Henry Schneiderman. Semi-supervised self-training of object detection models. 2005.   
+[7] Henry Scudder. Probability of error of some adaptive pattern-recognition machines. IEEE Transactions on Information Theory, 11(3):363–371, 1965.   
+[8] Qizhe Xie, Minh-Thang Luong, Eduard Hovy, and Quoc V Le. Self-training with noisy student improves imagenet classification. In CVPR, pages 10687–10698, 2020.   
+[9] Antti Rasmus, Harri Valpola, Mikko Honkala, Mathias Berglund, and Tapani Raiko. Semisupervised learning with ladder networks. In NeurIPS, pages 3546–3554, 2015.   
+[10] Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In NeurIPS, pages 1195– 1204, 2017.   
+[11] Qizhe Xie, Zihang Dai, Eduard Hovy, Thang Luong, and Quoc Le. Unsupervised data augmentation for consistency training. NeurIPS, 33, 2020.   
+[12] David Berthelot, Nicholas Carlini, Ian Goodfellow, Nicolas Papernot, Avital Oliver, and Colin Raffel. Mixmatch: A holistic approach to semi-supervised learning. NeurIPS, page 5050–5060, 2019.   
+[13] David Berthelot, Nicholas Carlini, Ekin D Cubuk, Alex Kurakin, Kihyuk Sohn, Han Zhang, and Colin Raffel. Remixmatch: Semi-supervised learning with distribution matching and augmentation anchoring. In ICLR, 2019.   
+[14] Kihyuk Sohn, David Berthelot, Nicholas Carlini, Zizhao Zhang, Han Zhang, Colin A Raffel, Ekin Dogus Cubuk, Alexey Kurakin, and Chun-Liang Li. Fixmatch: Simplifying semisupervised learning with consistency and confidence. NeurIPS, 33, 2020.   
+[15] Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In ICML, pages 41–48, 2009.   
+[16] Yves Grandvalet, Yoshua Bengio, et al. Semi-supervised learning by entropy minimization. In CAP, pages 281–296, 2005.   
+[17] Anastasia Pentina, Viktoriia Sharmanska, and Christoph H Lampert. Curriculum learning of multiple tasks. In CVPR, pages 5492–5500, 2015.   
+[18] Lu Jiang, Deyu Meng, Qian Zhao, Shiguang Shan, and Alexander Hauptmann. Self-paced curriculum learning. In AAAI, volume 29, 2015.   
+[19] Alex Graves, Marc G Bellemare, Jacob Menick, Remi Munos, and Koray Kavukcuoglu. Automated curriculum learning for neural networks. In ICML, pages 1311–1320. PMLR, 2017.   
+[20] Guy Hacohen and Daphna Weinshall. On the power of curriculum learning in training deep networks. In ICML, pages 2535–2544. PMLR, 2019.   
+[21] Daphna Weinshall, Gad Cohen, and Dan Amir. Curriculum learning by transfer learning: Theory and experiments with deep networks. In ICML, pages 5238–5246. PMLR, 2018.   
+[22] Eric Arazo, Diego Ortego, Paul Albert, Noel E O’Connor, and Kevin McGuinness. Pseudolabeling and confirmation bias in deep semi-supervised learning. In IJCNN, pages 1–8, 2020.   
+[23] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.   
+[24] Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. 2011.   
+[25] Adam Coates, Andrew $\mathrm { N g }$ , and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In AISTATS, pages 215–223, 2011.   
+[26] 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. Ieee, 2009.   
+[27] Avital Oliver, Augustus Odena, Colin Raffel, Ekin D Cubuk, and Ian J Goodfellow. Realistic evaluation of deep semi-supervised learning algorithms. In NeurIPS, pages 3239–3250, 2018.   
+[28] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, high-performance deep learning library. NeurIPS, 32:8026–8037, 2019.   
+[29] Ilya Sutskever, James Martens, George Dahl, and Geoffrey Hinton. On the importance of initialization and momentum in deep learning. In ICML, pages 1139–1147. PMLR, 2013.   
+[30] Boris T Polyak. Some methods of speeding up the convergence of iteration methods. Ussr computational mathematics and mathematical physics, 4(5):1–17, 1964.   
+[31] Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. ICLR, 2016.   
+[32] Ekin D Cubuk, Barret Zoph, Jonathon Shlens, and Quoc V Le. Randaugment: Practical automated data augmentation with a reduced search space. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pages 702–703, 2020.   
+[33] 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.   
+[34] Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. In BMVC, 2016.   
+[35] Tianyi Zhou, Shengjie Wang, and Jeff Bilmes. Time-consistent self-supervision for semisupervised learning. In ICML, pages 11523–11533. PMLR, 2020.   
+[36] Mamshad Nayeem Rizve, Kevin Duarte, Yogesh S Rawat, and Mubarak Shah. In defense of pseudo-labeling: An uncertainty-aware pseudo-label selection framework for semi-supervised learning. arXiv preprint arXiv:2101.06329, 2021.   
+[37] Chen Gong, Dacheng Tao, Stephen J Maybank, Wei Liu, Guoliang Kang, and Jie Yang. Multimodal curriculum learning for semi-supervised image classification. IEEE Transactions on Image Processing, 25(7):3249–3260, 2016.   
+[38] Hoel Kervadec, Jose Dolz, Éric Granger, and Ismail Ben Ayed. Curriculum semi-supervised segmentation. In International Conference on Medical Image Computing and Computer-Assisted Intervention, pages 568–576. Springer, 2019.   
+[39] Qing Yu, Daiki Ikami, Go Irie, and Kiyoharu Aizawa. Multi-task curriculum framework for open-set semi-supervised learning. In ECCV, pages 438–454. Springer, 2020.   
+[40] Yue Han, Yuhong Liu, and Zhigang Jin. Sentiment analysis via semi-supervised learning: a model based on dynamic threshold and multi-classifiers. Neural Computing and Applications, 32(9):5117–5129, 2020.   
+[41] Zhedong Zheng and Yi Yang. Rectifying pseudo label learning via uncertainty estimation for domain adaptive semantic segmentation. IJCV, 129(4):1106–1120, 2021.   
+[42] Paola Cascante-Bonilla, Fuwen Tan, Yanjun Qi, and Vicente Ordonez. Curriculum labeling: Revisiting pseudo-labeling for semi-supervised learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 35, pages 6912–6920, 2021.

parse/train/3qMwV98zLIk/3qMwV98zLIk_content_list.json

@@ -0,0 +1,1181 @@
+[
+    {
+        "type": "text",
+        "text": "FlexMatch: Boosting Semi-Supervised Learning with Curriculum Pseudo Labeling ",
+        "text_level": 1,
+        "bbox": [
+            209,
+            122,
+            790,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Bowen Zhang∗ Tokyo Institute of Technology bowen.z.ab@m.titech.ac.jp ",
+        "bbox": [
+            245,
+            226,
+            464,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yidong Wang∗ Tokyo Institute of Technology wang.y.ca@m.titech.ac.jp ",
+        "bbox": [
+            544,
+            226,
+            751,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wenxin Hou Microsoft wenxinhou@microsoft.com ",
+        "bbox": [
+            186,
+            290,
+            385,
+            330
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hao Wu Tokyo Institute of Technology wu.h.aj@m.titech.ac.jp ",
+        "bbox": [
+            401,
+            290,
+            601,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jindong Wang† Microsoft Research Asia jindwang@microsoft.com ",
+        "bbox": [
+            622,
+            289,
+            812,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Manabu Okumura† Tokyo Institute of Technology oku@pi.titech.ac.jp ",
+        "bbox": [
+            250,
+            352,
+            447,
+            395
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Takahiro Shinozaki† Tokyo Institute of Technology shinot@ict.e.titech.ac.jp ",
+        "bbox": [
+            531,
+            352,
+            746,
+            395
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            430,
+            535,
+            446
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The recently proposed FixMatch achieved state-of-the-art results on most semisupervised learning (SSL) benchmarks. However, like other modern SSL algorithms, FixMatch uses a pre-defined constant threshold for all classes to select unlabeled data that contribute to the training, thus failing to consider different learning status and learning difficulties of different classes. To address this issue, we propose Curriculum Pseudo Labeling (CPL), a curriculum learning approach to leverage unlabeled data according to the model’s learning status. The core of CPL is to flexibly adjust thresholds for different classes at each time step to let pass informative unlabeled data and their pseudo labels. CPL does not introduce additional parameters or computations (forward or backward propagation). We apply CPL to FixMatch and call our improved algorithm FlexMatch. FlexMatch achieves state-of-the-art performance on a variety of SSL benchmarks, with especially strong performances when the labeled data are extremely limited or when the task is challenging. For example, FlexMatch achieves $1 3 . 9 6 \\%$ and $1 8 . 9 6 \\%$ error rate reduction over FixMatch on CIFAR-100 and STL-10 datasets respectively, when there are only 4 labels per class. CPL also significantly boosts the convergence speed, e.g., FlexMatch can use only 1/5 training time of FixMatch to achieve even better performance. Furthermore, we show that CPL can be easily adapted to other SSL algorithms and remarkably improve their performances. We open-source our code at https://github.com/TorchSSL/TorchSSL. ",
+        "bbox": [
+            233,
+            460,
+            766,
+            737
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            762,
+            310,
+            780
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Semi-supervised learning (SSL) has attracted increasing attention in recent years due to its superiority in leveraging a large amount of unlabeled data. This is particularly advantageous when the labeled data are limited in quantity or laborious to obtain. Consistency regularization [1–3] and pseudo labeling [4–8] are two powerful techniques for utilizing unlabeled data and have been widely used in modern SSL algorithms [9–13]. The recently proposed FixMatch [14] achieves competitive results by combining these techniques with weak and strong data augmentations and using cross-entropy loss as the consistency regularization criterion. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            864
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "However, a drawback of FixMatch and other popular SSL algorithms such as Pseudo-Labeling [4] and Unsupervised Data Augmentation (UDA) [11] is that they rely on a fixed threshold to compute the unsupervised loss, using only unlabeled data whose prediction confidence is above the threshold. While this strategy can make sure that only high-quality unlabeled data contribute to the model training, it ignores a considerable amount of other unlabeled data, especially at the early stage of the training process, where only a few unlabeled data have their prediction confidence above the threshold. Moreover, modern SSL algorithms handle all classes equally without considering their different learning difficulties. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            237
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To address these issues, we propose Curriculum Pseudo Labeling (CPL), a curriculum learning [15] strategy to take into account the learning status of each class for semi-supervised learning. CPL substitutes the pre-defined thresholds with flexible thresholds that are dynamically adjusted for each class according to the current learning status. Notably, this process does not introduce any additional parameter (hyper-parameter or trainable parameter) or extra computation (forward or back propagation). We apply this curriculum learning strategy directly to FixMatch and call the improved algorithm FlexMatch. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            340
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While the training speed remains as efficient as that of FixMatch, FlexMatch converges significantly faster and achieves state-of-the-art performances on most SSL image classification benchmarks. The benefit of introducing CPL is particularly remarkable when the labels are scarce or when the task is challenging. For instance, on the STL-10 dataset, FlexMatch achieves relative performance improvement over FixMatch by $1 8 . 9 6 \\%$ , $1 6 . 1 1 \\%$ , and $7 . 6 8 \\%$ when the label amount is 400, 2500, and 10000 respectively. Moreover, CPL further shows its superiority by boosting the convergence speed – with CPL, FlexMatch takes less than 1/5 training time of FixMatch to reach its final accuracy. Adapting CPL to other modern SSL algorithms also leads to improvements in accuracy and convergence speed. ",
+        "bbox": [
+            174,
+            345,
+            825,
+            472
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To sum up, this paper makes the following three contributions: ",
+        "bbox": [
+            173,
+            477,
+            583,
+            491
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose Curriculum Pseudo Labeling (CPL), a curriculum learning approach of dynamically leveraging unlabeled data for SSL. It is almost cost-free and can be easily integrated to other SSL methods.   \n• CPL significantly boosts the accuracy and convergence performance of several popular SSL algorithms on common benchmarks. Specifically, FlexMatch, the integration of FixMatch and CPL, achieves state-of-the-art results.   \n• We open-source TorchSSL, a unified PyTorch-based semi-supervised learning codebase for the fair study of SSL algorithms. TorchSSL includes implementations of popular SSL algorithms and their corresponding training strategies, and is easy to use or customize. ",
+        "bbox": [
+            217,
+            502,
+            825,
+            641
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Background ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            661,
+            308,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Consistency regularization follows the continuity assumption of SSL [1, 2]. The most basic consistency loss in SSL, such as in $\\Pi$ Model [9], Mean Teacher [10] and MixMatch [12], is the ℓ-2 loss: ",
+        "bbox": [
+            174,
+            693,
+            826,
+            722
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f690ed34d222f6c8b892f6b72245aa7c6a56e606710aa71a9f134e0b2d17d747.jpg",
+        "text": "$$\n\\sum _ { b = 1 } ^ { \\mu B } | | p _ { m } ( y | \\omega ( u _ { b } ) ) - p _ { m } ( y | \\omega ( u _ { b } ) ) | | _ { 2 } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            733,
+            624,
+            776
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $B$ is the batch size of labeled data, $\\mu$ is the ratio of unlabeled data to labeled data, $\\omega$ is a stochastic data augmentation function (thus the two terms in Eq.(1) are different), $u _ { b }$ denotes a piece of unlabeled data, and $p _ { m }$ represents the output probability of the model. With the introduction of pseudo labeling techniques [5, 7], the consistency regularization is converted to an entropy minimization process [16], which is more suitable for the classification task. The improved consistency loss with pseudo labeling can be represented as: ",
+        "bbox": [
+            176,
+            780,
+            825,
+            864
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/36b3f0c1f3f4d28e7d50f516e852bf71e42d6c7e8556f8a5015a1db0c6323aab.jpg",
+        "text": "$$\n\\frac { 1 } { \\mu B } \\sum _ { b = 1 } ^ { \\mu B } \\mathbb { 1 } ( \\operatorname* { m a x } ( p _ { m } ( y | \\omega ( u _ { b } ) ) ) > \\tau ) H ( \\hat { p } _ { m } ( y | \\omega ( u _ { b } ) ) , p _ { m } ( y | \\omega ( u _ { b } ) ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            271,
+            872,
+            723,
+            915
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/4268f791afd62be454ac4961a9143bcfb993683de92a9af07eca9c581cd26eb4.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of Curriculum Pseudo Label (CPL). The estimated learning effects of each class are decided by the number of unlabeled data samples falling into this class and above the fixed threshold. They are then used to adjust the flexible thresholds to let pass the optimal unlabeled data. Note that the estimated learning effects do not always grow – they may also decrease if the predictions of the unlabeled data fall into other classes in later iterations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            103,
+            795,
+            219
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $H$ is cross-entropy, $\\tau$ is the pre-defined threshold and $\\hat { p } _ { m } ( y | \\omega ( u _ { b } ) )$ is the pseudo label that can either be a ‘hard’ one-hot label [4, 14] or a sharpened ‘soft’ one [11]. The intention of using a threshold is to mask out noisy unlabeled data that have low prediction confidence. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "FixMatch utilizes such consistency regularization with strong augmentation to achieve competitive performance. For unlabeled data, FixMatch first uses weak augmentation to generate artificial labels. These labels are then used as the target of strongly-augmented data. The unsupervised loss term in FixMatch thereby has the form: ",
+        "bbox": [
+            174,
+            381,
+            825,
+            438
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ac92b41468f6fc9978b7ce65ae75059b8480e3030b1f64235bed4a1655f3d47f.jpg",
+        "text": "$$\n\\frac { 1 } { \\mu B } \\sum _ { b = 1 } ^ { \\mu B } \\mathbb { 1 } ( \\operatorname* { m a x } ( p _ { m } ( y | \\omega ( u _ { b } ) ) ) > \\tau ) H ( \\hat { p } _ { m } ( y | \\omega ( u _ { b } ) ) , p _ { m } ( y | \\Omega ( u _ { b } ) ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            271,
+            445,
+            723,
+            489
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\Omega$ is a strong augmentation function instead of weak augmentation $\\omega$ . ",
+        "bbox": [
+            176,
+            496,
+            671,
+            511
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Of the aforementioned works, the pre-defined threshold $( \\tau )$ is constant. We believe this can be improved because the data of some classes may be inherently more difficult to learn than others. Curriculum learning [15] is a learning strategy where learning samples are gradually introduced according to the model’s learning process. In such a way, the model is always optimally challenged. This technique is widely employed in deep learning research [17–21]. ",
+        "bbox": [
+            174,
+            516,
+            826,
+            587
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 FlexMatch ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            604,
+            295,
+            622
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Curriculum Pseudo Labeling ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            637,
+            416,
+            652
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While current SSL algorithms render pseudo labels of only high-confidence unlabeled data cut off by a pre-defined threshold, CPL renders the pseudo labels to different classes and at different time steps. Such a process is realized by adjusting the thresholds according to the model’s learning status of each class. ",
+        "bbox": [
+            174,
+            662,
+            826,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "However, it is non-trivial to dynamically determine the thresholds according to the learning status. The most ideal approach would be calculating evaluation accuracies for each class and use them to scale the threshold, as: ",
+        "bbox": [
+            174,
+            724,
+            825,
+            766
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/349a3f2495d7f3ec3136ea45781d9b5d7f96779e597aad6328669b25f36eb7d6.jpg",
+        "text": "$$\nT _ { t } ( c ) = a _ { t } ( c ) \\cdot \\tau ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            439,
+            765,
+            557,
+            782
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { T } _ { t } ( c )$ is the flexible threshold for class $c$ at time step $t$ and $a _ { t } ( c )$ is the corresponding evaluation accuracy. In this way, lower accuracy that indicates a less satisfactory learning status of the class will lead to a lower threshold that encourages more samples of this class to be learned. Since we cannot use the evaluation set in the model learning process, one may have to separate an extra validation set from the training set for such accuracy evaluations. However, this practice show two fatal problems: First, such a labeled validation set separated from the training set is expensive under SSL scenario as the labeled data are already scarce. Second, to dynamically adjust the thresholds in the training process, accuracy evaluations must be done continually at each time step $t$ , which will considerably slow down the training speed. ",
+        "bbox": [
+            173,
+            786,
+            825,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose Curriculum Pseudo Labeling (CPL) for semi-supervised learning. Our CPL uses an alternative way to estimate the learning status, which does not introduce additional inference processes, nor needs an extra validation set. As believed in [14], a high threshold that filters out noisy pseudo labels and leaves only high-quality ones can considerably reduce the confirmation bias [22]. Therefore, our key assumption is that when the threshold is high, the learning effect of a class can be reflected by the number of samples whose predictions fall into this class and above the threshold. Namely, the class with fewer samples having their prediction confidence reach the threshold is considered to have a greater learning difficulty or a worse learning status, formulated as: ",
+        "bbox": [
+            173,
+            90,
+            826,
+            203
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/849fb2dd9fa18cc77c2a8a20a0df9454d677342a4bc5d2d94f2f3d04eff8ec62.jpg",
+        "text": "$$\n\\sigma _ { t } ( c ) = \\sum _ { n = 1 } ^ { N } \\mathbb { 1 } ( \\operatorname* { m a x } ( p _ { m , t } ( y | u _ { n } ) ) > \\tau ) \\cdot \\mathbb { 1 } ( \\arg \\operatorname* { m a x } ( p _ { m , t } ( y | u _ { n } ) = c ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            207,
+            728,
+            250
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma _ { t } ( c )$ reflects the learning effect of class $c$ at time step $t$ . $p _ { m , t } ( y | u _ { n } )$ is the model’s prediction for unlabeled data $u _ { n }$ at time step $t$ , and $N$ is the total number of unlabeled data. When the unlabeled dataset is balanced (i.e., the number of unlabeled data belonging to different classes are equal or close), larger $\\sigma _ { t } ( c )$ indicates a better estimated learning effect. By applying the following normalization to $\\sigma _ { t } ( c )$ to make its range between 0 to 1, it can then be used to scale the fixed threshold $\\tau$ : ",
+        "bbox": [
+            173,
+            253,
+            825,
+            324
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/588d756802b91ecf5c9cff8aacb9db64047b5bcb81d1a3a5df1bbd3f3249941b.jpg",
+        "text": "$$\n\\beta _ { t } ( c ) = \\frac { \\sigma _ { t } ( c ) } { \\operatorname* { m a x } _ { c } \\sigma _ { t } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            327,
+            555,
+            366
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e6cbcade819159442147d317a65b8cce88fbd0a8b8be97296ddf260251d8edbf.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { T } _ { t } ( c ) = \\beta _ { t } ( c ) \\cdot \\tau . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            439,
+            375,
+            560,
+            392
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One characteristic of such a normalization approach is that the best-learned class has its $\\beta _ { t } ( c )$ equal to 1, causing its flexible threshold equal to $\\tau$ . This is desirable. For classes that are hard to learn, the thresholds are lowered down, encouraging more training samples in these classes to be learned. This also improves the data utilization ratio. As learning proceeds, the threshold of a well-learned class is raised higher to selectively pick up higher-quality samples. Eventually, when all classes have reached reliable accuracies, the thresholds will all approach $\\tau$ . Note that the thresholds do not always grow, it may also decrease if the unlabeled data is classified into a different class in later iterations. This new threshold is used for calculating the unsupervised loss in FlexMatch, which can be formulated as: ",
+        "bbox": [
+            173,
+            398,
+            826,
+            511
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e0e5d340132d1d5db24caf2875e4b92f37ef7ab8feea80c64ef1ede9373e84ae.jpg",
+        "text": "$$\n\\mathcal { L } _ { u , t } = \\frac { 1 } { \\mu B } \\sum _ { b = 1 } ^ { \\mu B } \\mathbb { 1 } ( \\operatorname* { m a x } ( q _ { b } ) > \\mathcal { T } _ { t } ( \\arg \\operatorname* { m a x } ( q _ { b } ) ) ) H ( \\hat { q } _ { b } , p _ { m } ( y | \\Omega ( u _ { b } ) ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            515,
+            728,
+            559
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $q _ { b } = p _ { m } ( y | \\omega ( u _ { b } ) )$ . The flexible thresholds are updated at each iteration. Finally, we can formulate the loss in FlexMatch as the weighted combination (by $\\lambda$ ) of supervised and unsupervised loss: ",
+        "bbox": [
+            174,
+            563,
+            823,
+            604
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e295d5648c44a267df1c91c2eb039af22709965e23bddfe52bc84ad6fa2e7242.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { t } = \\mathcal { L } _ { s } + \\lambda \\mathcal { L } _ { u , t } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            437,
+            603,
+            560,
+            621
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { L } _ { s }$ is the supervised loss on labeled data: ",
+        "bbox": [
+            173,
+            622,
+            488,
+            636
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/79610780c647bd0bc6c709c6dc3e98647f4ec8487aaa3448761a1fadab9d83ac.jpg",
+        "text": "$$\n\\mathcal { L } _ { s } = \\frac { 1 } { B } \\sum _ { b = 1 } ^ { B } H \\big ( y _ { b } , p _ { m } ( y | \\omega ( x _ { b } ) ) \\big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            640,
+            614,
+            684
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that the cost of introducing CPL is almost free. Practically, every time the prediction confidence of an unlabeled data $u _ { n }$ is above the fixed threshold $\\tau$ , the data, and its predicted class are marked and will be used for calculating $\\beta _ { t } ( c )$ at the next time step. Such marking actions are bonus actions each time the consistency loss is computed. Therefore, FlexMatch does not introduce additional forward propagation processes for evaluating the model’s learning status, nor new parameters. ",
+        "bbox": [
+            173,
+            694,
+            825,
+            763
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Threshold warm-up ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            779,
+            352,
+            795
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We noticed in our experiments that at the early stage of the training, the model may blindly predict most unlabeled samples into a certain class depending on the parameter initialization(i.e., more likely to have confirmation bias). Hence, the estimated learning status may not be reliable at this stage. Therefore, we introduce a warm-up process by rewriting the denominator in Eq. (6) as: ",
+        "bbox": [
+            174,
+            804,
+            826,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d4924ad25db3be5d95f86dfb4a8a128e58cec2149701ef06d03504f1fae3c2bc.jpg",
+        "text": "$$\n\\beta _ { t } ( c ) = \\frac { \\sigma _ { t } ( c ) } { \\operatorname* { m a x } \\left\\{ \\operatorname* { m a x } _ { c } \\sigma _ { t } , N - \\sum _ { c } \\sigma _ { t } \\right\\} } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            864,
+            624,
+            916
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1: Input: $\\mathcal X = \\{ ( x _ { m } , y _ { m } ) : m \\in ( 1 , \\ldots , M ) \\} , \\mathcal { U } = \\{ u _ { n } : n \\in ( 1 , \\ldots , N ) \\}$ {M labeled data and   \nN unlabeled data.}   \n2: $\\hat { u } _ { n } = - 1 : n \\in ( 1 , \\dots , N )$ {Initialize predictions of all unlabeled data as $^ { - 1 }$ indicating unused.}   \n3: while not reach the maximum iteration do   \n4: for $c = 1$ to $C$ do   \n5: $\\begin{array} { r } { \\sigma ( c ) = \\sum _ { n = 1 } ^ { N } \\mathbb { 1 } ( \\hat { u } _ { n } = c ) } \\end{array}$ {Compute estimated learning effect.}   \n6: if max $\\begin{array} { r } { \\sigma ( c ) < \\sum _ { n = 1 } ^ { N } \\mathbb { 1 } ( \\hat { u } _ { n } = - 1 ) } \\end{array}$ then   \n7: Calculate $\\beta ( c )$ using Eq. (11) {Threshold warms up when unused data dominate.}   \n8: else   \n9: Calculate $\\beta ( c )$ using Eq. (6) {Compute normalized estimated learning effect.}   \n10: end if   \n11: Calculate $\\tau ( c )$ using Eq. (7) {Determine the flexible threshold for class $c$ .}   \n12: end for   \n13: for $b = 1$ to $\\mu B$ do   \n14: if $p _ { m } ( y | \\omega ( u _ { b } ) ) > \\tau$ then   \n15: $\\hat { u } _ { b } = \\arg \\operatorname* { m a x } q _ { b }$ {Update the prediction of unlabeled data $u _ { b }$ .}   \n16: end if   \n17: end for   \n18: Compute the loss via Eq. (8), (10) and (9).   \n19: end while   \n20: Return: Model parameters. ",
+        "bbox": [
+            176,
+            107,
+            823,
+            406
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the term $\\begin{array} { r } { N - \\sum _ { c = 1 } ^ { C } \\sigma _ { t } ( c ) } \\end{array}$ can be regarded as the number of unlabeled data that have not been used. This ensures that at the beginning of the training, all estimated learning effects gradually rise from 0 until the number of unused unlabeled data is no longer predominant. The duration of such a period depends on the unlabeled data amount (ref. $N$ in Eq. (11)) and the learning difficulty (ref. the growing speed of $\\sigma _ { t } ( c )$ in Eq. (11)) of the dataset. In practice, such a warm-up process is very easy to implement as we can add an extra class to denote the unused unlabeled data. Thus calculating the denominator of Eq. (11) is simply converted to finding the maximum among $c + 1$ classes. ",
+        "bbox": [
+            173,
+            438,
+            825,
+            537
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Non-linear mapping function ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            560,
+            415,
+            575
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The flexible threshold in Eq. (7) is determined by the normalized estimated learning effects via a linear mapping. However, it may not be the most suitable mapping in the real training process, where the increase or decrease of $\\beta _ { t } ( c )$ may make big jumps in the early phase where the predictions of the model are still unstable; and only make small fluctuations after the class is well-learned in the mid and late training stage. Therefore, it is preferable if the flexible thresholds can be more sensitive when $\\beta _ { t } ( c )$ is large and vice versa. ",
+        "bbox": [
+            173,
+            588,
+            825,
+            672
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We propose a non-linear mapping function to enable the thresholds to have a non-linear increasing curve when $\\beta _ { t } ( c )$ ranges uniformly from 0 to 1, as formulated below: ",
+        "bbox": [
+            171,
+            678,
+            823,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5e98b4f7d8dceb824b82305559d49d91057058d4e1e5264fa1da674a5512f4b2.jpg",
+        "text": "$$\n\\mathscr { T } _ { t } ( c ) = \\mathcal { M } ( \\beta _ { t } ( c ) ) \\cdot \\tau ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            720,
+            573,
+            738
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { M } ( \\cdot )$ is a non-linear mapping function. It is clear that Eq. (7) can be seen as a special case by setting $\\mathcal { M }$ to the identity function. The mapping function $\\mathcal { M }$ should be monotonically increasing and have a maximum no larger than $1 / \\tau$ (otherwise the flexible threshold can be larger than 1 and filter out all samples). To avoid introducing additional hyper-parameters (e.g. lower limits of the flexible thresholds), we consider the mapping function to have a range from 0 to 1 so that the flexible thresholds range from 0 to $\\tau$ . ",
+        "bbox": [
+            173,
+            751,
+            825,
+            834
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A monotone increasing convex function lets the thresholds grow slowly when $\\beta _ { t } ( c )$ is small, and become more sensitive as $\\beta _ { t } ( c )$ gets larger. Hence, we intuitively choose a convex function with the above-mentioned properties to compare among mapping $\\begin{array} { r } { \\mathcal { M } ( x ) = \\frac { x } { 2 - x } } \\end{array}$ for our experiments. We also conduct an ablation studyh different convexity and concavity in Sec. 4.4. The full algorithm of FlexMatch is shown in Algorithm 1. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/0ad5f98df0e477cc64b312f58fdbd34c259dc7caeba36009be18c0a809950e58.jpg",
+        "table_caption": [
+            "Table 1: Error rates on CIFAR-10/100, SVHN, and STL-10 datasets. The ‘Flex’ prefix denotes applying CPL to the algorithm, and ‘PL’ is an abbreviation of Pseudo-Labeling. STL-10 dataset does not have label information for unlabeled data, thus its fully-supervised result is unavailable. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td colspan=\"3\">CIFAR-10</td><td colspan=\"3\">CIFAR-100</td><td colspan=\"3\">STL-10</td><td colspan=\"2\">SVHN</td></tr><tr><td>Label Amount</td><td>40</td><td>250</td><td>4000</td><td>400</td><td>2500</td><td>10000</td><td>40</td><td>250</td><td>1000</td><td>40</td><td>1000</td></tr><tr><td>PL</td><td>74.61±0.26</td><td>46.49±2.20</td><td>15.08±0.19</td><td>87.45±0.85</td><td>57.74±0.28</td><td>36.55±0.24</td><td>74.68±0.99</td><td>55.45±2.43</td><td>32.64±0.71</td><td>64.61±5.60</td><td>9.40±0.32</td></tr><tr><td>Flex-PL</td><td>73.74±1.96</td><td>46.14±1.81</td><td>14.75±0.19</td><td>85.72±0.46</td><td>56.12±0.51</td><td>35.60±0.15</td><td>73.42±2.19</td><td>52.06±2.50</td><td>32.05±0.37</td><td>63.21±3.64</td><td>12.05±0.54</td></tr><tr><td>UDA</td><td>10.62±3.75</td><td>5.16±0.06</td><td>4.29±0.07</td><td>46.39±1.59</td><td>27.73±0.21</td><td>22.49±0.23</td><td>37.42±8.44</td><td>9.72±1.15</td><td>6.64±0.17</td><td>5.12±4.27</td><td>1.89±0.01</td></tr><tr><td>Flex-UDA</td><td>5.44±0.52</td><td>5.02±0.07</td><td>4.24±0.06</td><td>45.17±1.88</td><td>27.08±0.15</td><td>21.91±0.10</td><td>29.53±2.10</td><td>9.03±0.45</td><td>6.10±0.25</td><td>3.42±1.51</td><td>2.02±0.05</td></tr><tr><td>FixMatch</td><td>7.47±0.28</td><td>4.86±0.05</td><td>4.21±0.08</td><td>46.42±0.82</td><td>28.03±0.16</td><td>22.20±0.12</td><td>35.97±4.14</td><td>9.81±1.04</td><td>6.25±0.33</td><td>3.81±1.18</td><td>1.96±0.03</td></tr><tr><td>FlexMatch</td><td>4.97±0.06</td><td>4.98±0.09</td><td>4.19±0.01</td><td>39.94±1.62</td><td>26.49±0.20</td><td>21.90±0.15</td><td>29.15 ±4.16</td><td>8.23±0.39</td><td>5.77±0.18</td><td>8.19±3.20</td><td>6.72±0.30</td></tr><tr><td>Fully-Supervised</td><td></td><td>4.62± 0.05</td><td></td><td></td><td>19.30± 0.09</td><td></td><td></td><td>：</td><td></td><td>2.13± 0.02</td><td></td></tr></table>",
+        "bbox": [
+            173,
+            137,
+            825,
+            239
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            253,
+            312,
+            271
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate FlexMatch and other CPL-enabled algorithms on common SSL datasets: CIFAR10/100 [23], SVHN [24], STL-10 [25] and ImageNet [26], and extensively investigate the performance under various labeled data amounts. We mainly compare our method with Pseudo-Labeling [4], UDA [11] and FixMatch [14], since they all involve a pre-defined threshold. The results of other popular SSL algorithms are in the appendix. We also add a fully-supervised experiment for each dataset to better understand the results of SSL algorithms. Note that previously suggested [27] fully-supervised comparisons use only the labeled set for training, whose purpose is to manifest the improvement brought by the introduction of unlabeled data. With the development of modern SSL algorithms, however, semi-supervised approaches are achieving competitive performance with supervised ones, or even better performance due to the strength of consistency regularization. Therefore, our fully-supervised comparisons are conducted with all data labeled, and apply weak data augmentations following Eq. (10). We re-implement all baselines using our PyTorch [28] codebase: TorchSSL, which is introduced in the appendix. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            465
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For a fair comparison, we use the same hyper-parameters following FixMatch [14]. Concretely, the optimizer for all experiments is standard stochastic gradient descent (SGD) with a momentum of 0.9 [29, 30]. For all datasets, we use an initial learning rate of 0.03 with a cosine learning rate decay schedule [31] as $\\eta = \\eta _ { 0 } \\cos ( \\frac { 7 \\pi k } { 1 6 K } )$ , where $\\eta _ { 0 }$ is the initial learning rate, $k$ is the current training step and $K$ is the total training step that is set to $2 ^ { 2 0 }$ . We also perform an exponential moving average with the momentum of 0.999. The batch size of labeled data is 64 except for ImageNet. $\\mu$ is set to be 1 for Pseudo-Label and 7 for UDA, FixMatch, and FlexMatch. $\\tau$ is set to 0.8 for UDA and 0.95 for Pseudo Label, FixMatch, and FlexMatch. These setups follow the original papers. The strong augmentation function used in our experiments is RandAugment [32]. We use ResNet-50 [33] for the ImageNet experiment and Wide ResNet (WRN) [34] and its variant [35] for other datasets. Detailed hyper-parameters are listed in the appendix. ",
+        "bbox": [
+            174,
+            470,
+            825,
+            627
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We adopt two evaluation metrics: (1) the median error rate of the last 20 checkpoints following [12, 14], and (2) the best error rate in all checkpoints. We argue that the median approach is not suitable when the convergence speeds of the algorithms show significant differences – the large number of redundant iterations may result in over-fitting for the fast-converge algorithms. Therefore, we report the best error rates for all algorithms, while the results of the median approach are also provided in the appendix, showing that our FlexMatch still achieves the best performance. We run each task three times using distinct random seeds to obtain the error bars. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            729
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Main results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            746,
+            299,
+            761
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The classification error rates on CIFAR-10/100, STL-10 and SVHN datasets are in Table 1, and the results on ImageNet are in Sec. 4.2. Note that the SVHN dataset used in our experiment also includes the extra set that contains 531,131 additional samples. Results demonstrate that FlexMatch achieves the state-of-the-art performance on most of the benchmark datasets except for SVHN where Flex-UDA (i.e., UDA with CPL) and UDA have the lowest error rate on the 40-label split and the 1000-label split, respectively. We also provide the detailed precision, recall, F1, and AUC results in the appendix. Our CPL (FlexMatch) has the following advantages: ",
+        "bbox": [
+            174,
+            771,
+            825,
+            869
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "CPL achieves better performance on tasks with extremely limited labeled data. Our FlexMatch significantly outperforms other methods when the amount of labels is extremely small. For instance, on the CIFAR-100 dataset with 400 labels (i.e., only 4 label samples per class), FlexMatch achieves an average error rate of $3 9 . 9 4 \\%$ , which significantly outperforms FixMatch $( 4 6 . 4 2 \\% )$ . ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/95e0b0a2acc75c03a3ed45c4def27cd321c39eeea99d0163596dd74ef0d7f61c.jpg",
+        "image_caption": [
+            "Figure 3: Convergence analysis of FixMatch and FlexMatch. (a) and (b) depict the loss and top1-accuracy on CIFAR-100 with 400 labels. Evaluations are done every 5K iterations. (c) and (d) demonstrate the class-wise accuracy within the first 200K iterations on CIFAR-10 dataset. The numbers in legend correspond to the ten classes in the dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            95,
+            813,
+            205
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            291,
+            823,
+            319
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "CPL improves the performance of existing SSL algorithms. Other than FixMatch, CPL can also improve the performance of other existing SSL algorithms such as Pseudo-Labeling and UDA. For instance, the error rate is reduced from $3 7 . 4 \\%$ to $2 9 . 5 3 \\%$ for UDA on the STL-10 40-label split after introducing CPL (refer to as Flex-UDA in Table 1). These results further prove the effectiveness of CPL in better leveraging unlabeled data. Figure 2 shows the average running time of a single iteration with or without adding our CPL, it is clear that while improving the performance of existing SSL algorithms, our CPL does not introduce additional computational burden. ",
+        "bbox": [
+            174,
+            334,
+            614,
+            486
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/267f4b68f8f3b6cde9f37de6e95bc2454642fe2c44002364f1a0348fc5674f32.jpg",
+        "image_caption": [
+            "Figure 2: Average running time of one iteration on a single GeForce RTX 3090 GPU. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            629,
+            335,
+            821,
+            438
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "CPL achieves better performance on complicated tasks. The STL-10 dataset contains unlabeled data from a similar but broader distribution of images than its labeled set. The existence of new types of objects in the unlabeled dataset makes STL-10 a more challenging and realistic task. FlexMatch achieves greater performance improvement under such a challenging situation. The error rate on STL-10 with only 40 labels is $2 9 . 1 5 \\%$ , which is relatively $1 8 . 9 6 \\%$ better than FixMatch $( 3 5 . 9 7 \\% )$ . Similar strong improvements are also observed on CIFAR-100 dataset, which has as many as one hundred classes. ",
+        "bbox": [
+            173,
+            502,
+            825,
+            599
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also analyze the reason why FlexMatch performs less favorably on SVHN. This is probably because SVHN is a relatively simple (i.e., to classify digits) yet unbalanced dataset. The class-wise imbalance leads to the classes with fewer samples never have their estimated learning effects close to 1 according to Eq. (6), even when they are already well-learned. Such low thresholds allow noisy pseudo-labeled samples to be trusted and learned throughout the training process, which is also reflected by the loss descent curve where the low-threshold classes have major fluctuations. FixMatch, on the other hand, fixes its threshold at 0.95 to filter out noisy samples. Such a fixed high threshold is not preferable with respect to both accuracies of hard-to-learn classes and overall convergence speed as explained earlier, but since SVHN is an easy task, the model can easily learn the task and make high-confidence predictions, setting a high-fixed threshold thus becomes less problematic and has its advantages overweighed. ",
+        "bbox": [
+            173,
+            606,
+            825,
+            757
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Results on ImageNet ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            775,
+            356,
+            790
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also verify the effectiveness of CPL on ImageNet-1K [26] which is a much more realistic and complicated dataset. We randomly choose the same 100K labeled data (i.e., 100 labels per class), which is less than $8 \\%$ of the total labels. The hyper-parameters used for ImageNet can be found in the appendix, where the two algorithms share the same hyper-parameters. We show the error rate comparison after running $2 ^ { 2 0 }$ iterations in Table 2. This result indicates that when the task is complicated, despite the class imbalance issue (the number of images within each class ranges from 732 to 1300), CPL can still bring improvements. Note that this result does not represent the best performance of each algorithm as the model cannot fully converge after $2 ^ { 2 0 }$ iterations, and due to the computational resource limitation, we did not further tune the hyper-parameters to obtain the best results on ImageNet. ",
+        "bbox": [
+            174,
+            800,
+            612,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/d230303ab6e372be670dfa3c4d86048e8a9122556decac51c67e256cd45beb8e.jpg",
+        "table_caption": [
+            "Table 2: Error rate results on ImageNet after $2 ^ { 2 0 }$ iterations. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Top-1</td><td>Top-5</td></tr><tr><td>FixMatch FlexMatch</td><td>43.66 42.02</td><td>21.80 19.49</td></tr></table>",
+        "bbox": [
+            627,
+            834,
+            821,
+            887
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5151884492ed3cfe65eefa496339c009a476cb6955e2bded3395e9a33e4cc977.jpg",
+        "image_caption": [
+            "Figure 4: Ablation study of FlexMatch. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            95,
+            807,
+            218
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            255,
+            825,
+            310
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Convergence speed acceleration ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            329,
+            433,
+            343
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Another strong advantage of FlexMatch is its superior convergence speed. Figure 3(a) and 3(b) shows the comparison between FlexMatch and FixMatch with respect to the loss and top-1-accuracy on CIFAR-100 400-label split. The loss of FlexMatch decreases much faster and smoother than FixMatch, demonstrating its superior convergence speed. The major fluctuations of the loss in FixMatch may due to the pre-defined threshold that lets pass most unlabeled data belonging to certain classes, whereas with CPL a larger batch of unlabeled data containing samples from various classes enables the gradient to more directly head toward the global optimum. As a result, with only 50K iterations, FlexMatch has already surpassed the final results of FixMatch. After 800K iterations, however, we observe a further decrease in loss and accuracy. This is likely due to over-fitting, which also occurs in FixMatch after 900K iterations. Thus, we believe it is not fair to use the median results of the last few checkpoints for evaluating algorithms with different convergence speeds. ",
+        "bbox": [
+            174,
+            356,
+            825,
+            507
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We further compare the class-wise accuracy of FixMatch and FlexMatch on CIFAR-10 in their early training stages. As shown in Figure 3(c) and 3(d), at iteration 200K, FixMatch only hits an overall accuracy of $5 6 . 3 5 \\%$ as half of the classes are still learned unsatisfactorily, whereas FlexMatch has already achieved an overall accuracy of $9 4 . 2 9 \\%$ which is even higher than the final accuracy reached by FixMatch after 1M iterations. It is manifest that the introduction of CPL successfully encourages the model to proactively learn those difficult classes thereby improving the overall learning effect. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            597
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 Ablation study ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            614,
+            313,
+            630
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments to evaluate three components of FlexMatch: the upper limit of thresholds $\\tau$ mapping functions $\\mathcal M ( x )$ , and threshold warm-up. ",
+        "bbox": [
+            176,
+            641,
+            825,
+            670
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Threshold upper bound. We investigate 5 different $\\tau$ values and 3 different mapping functions on CIFAR-10 dataset with 40 labels. As shown in Figure 4(a), the optimal choice of $\\tau$ is around 0.95, either increasing or decreasing this value results in a performance decay. Note that in FlexMatch, tuning $\\tau$ does not only affect the upper limit of the threshold but also the estimated learning effects because they are determined by the number of samples that fall above $\\tau$ . ",
+        "bbox": [
+            174,
+            685,
+            825,
+            756
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Mapping function. We explore three different mapping functions in Figure 4(b): (1) concave: $\\mathcal { M } ( x ) = \\ln ( x + 1 ) / \\ln 2$ , (2) linear: $\\mathcal { M } ( x ) = x$ , and (3) convex: $\\mathcal { M } ( x ) = x / ( 2 - x )$ . We see that the convex function shows the best performance and the concave function shows the worst. Although tweaking the degree of convexity may probably lead to further improvement, we do not make further investigation in this paper. It is noteworthy that all these functions have their outputs grow from 0 to 1 when the inputs go from 0 to 1. One may also design a function with a different range, for instance, from 0.5 to 1. In this case, it is equivalent to setting a lower limit to the flexible threshold so that even at the beginning of the training, only samples with prediction confidence higher than this limit will contribute to the unsupervised loss. We do not include such a lower limit in FlexMatch since it will introduce a new hyper-parameter. However, we did find that setting a lower limit at 0.5 can slightly improve the performance. A possible reason is that the lower threshold prevents noisy training caused by incorrect pseudo labels at the early stage [36]. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Threshold warm-up. We analyze the performance of threshold warm-up on both CIFAR-10 (40 labels) and CIFAR-100 (400 labels) datasets. As shown in Figure 4(c), threshold warm-up can bring about $0 . 2 \\%$ absolute improvement on CIFAR-10 and about $1 \\%$ on CIFAR-100. At the beginning of the training without the threshold warm-up, the flexible thresholds may go through heavy fluctuations because the denominator in Eq.(6) is small. In the meantime, there will always be some classes whose flexible thresholds reach or approach $\\tau$ , thereby filtering out most unlabeled data in the batch. The threshold warm-up solves this issue by gradually raising the thresholds of all classes from zero – it creates a learning boom at the early training stage where most of the unlabeled data can be utilized. ",
+        "bbox": [
+            174,
+            141,
+            825,
+            253
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Comparison with class balancing objectives. CPL has the effect of balancing across classes the number of unlabeled samples used to compute pseudo-labeling loss in each batch. Similar effect can be achieved by making the marginal class distribution close to a uniform distribution for each batch. We conduct such a comparative experiment by directly adding an additional objective to FixMatch: $\\begin{array} { r } { \\mathcal { L } _ { b } = \\sum _ { c } q _ { c } \\log ( q _ { c } / \\hat { p } _ { c } ) } \\end{array}$ [22], where $\\hat { p } _ { c }$ is the mean predicted probability of class $c$ across all samples in the batch, and $q$ is a uniform distribution: $q _ { c } = 1 / C$ . The error rate of adding such an objective is $7 . 1 6 \\%$ on the CIFAR-10 40-label split (compared with FixMatch $7 . 4 7 \\% \\pm 0 . 2 8$ and FlexMatch $4 . 9 7 \\% \\pm 0 . 0 6 )$ . While this approach requires instances of each class within each batch to be balanced to make sense, CPL does not have such a constraint. It is more flexible and involves less human intervention to adjust thresholds than adjusting model’s predictions. ",
+        "bbox": [
+            174,
+            273,
+            825,
+            412
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            439,
+            321,
+            457
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pseudo-Labeling [4] is a pioneer SSL method that uses hard artificial labels converted from model predictions. A confidence-based strategy was used in [6] along with pseudo labeling so that the unlabeled data are used only when the predictions are sufficiently confident. Such confidence-based thresholding also presents in recently proposed UDA [11] and FixMatch [14] with the difference being that UDA used sharpened ‘soft’ pseudo labels with a temperature whereas Fixmatch adopted one-hot ‘hard’ labels. The success of UDA and FixMatch, however, relies heavily on the usage of strong data augmentations to improve the consistency regularization. ReMixMatch [13] also leveraged such strong augmentations. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            587
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The combination of curriculum learning and semi-supervised learning is popular in recent years [37– 39]. For multi-model image classification task, [37] optimized the learning process of unlabeled images by judging their reliability and discriminability. In [38], the easy image-level properties are learned first and then used to facilitate segmentation via constrained CNNs. Curriculum learning is also used to alleviate out-of-distribution problems by picking up in-distribution samples from unlabeled data according to the out-of-distribution scores [39]. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            676
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Several researches have investigated on dynamic threshold in related fields such as sentiment analysis [40] and semantic segmentation [41]. In [40], the threshold was gradually reduced to make high-quality data selected into labeled data set in the early stage and large-quantity in the later stage. An extra classifier is added to automate the threshold to deal with domain inconsistency in [41]. [42] introduced curriculum learning to self-training with a steadily increasing threshold and achieved near state-of-the-art results. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            765
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            791,
+            449,
+            809
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduce Curriculum Pseudo Labeling (CPL), a curriculum learning approach of leveraging unlabeled data for SSL. CPL dramatically improves the performance and convergence speed of SSL algorithms that involve thresholds while being extremely simple and almost cost-free. FlexMatch, our improved algorithm of FixMatch, achieves state-of-the-art performance on a variety of SSL benchmarks. In future work, we would like to improve our method under the long-tail scenario where the unlabeled data belonging to each class are extremely unbalanced. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Broader Impact ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            310,
+            107
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "CPL fills the gap that no modern SSL algorithm considers the inherent learning difficulties of different classes during the training, and shows that by doing so, the convergence speed and final accuracy can both be improved. We hope that CPL can attract more future attention to explore the effectiveness of utilizing unlabeled data according to the model’s learning status as well as the per-class learning difficulty. ",
+        "bbox": [
+            174,
+            121,
+            825,
+            190
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Funding Disclosure ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            209,
+            338,
+            227
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Funding in direct support of this work: computing resource granted by Tokyo Institute of Technology and Microsoft Research Asia. This work was partially supported by Toray Science Foundation. ",
+        "bbox": [
+            176,
+            241,
+            823,
+            268
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            287,
+            266,
+            304
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Philip Bachman, Ouais Alsharif, and Doina Precup. Learning with pseudo-ensembles. In NeurIPS, pages 3365–3373, 2014.   \n[2] Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. ICLR, 2017.   \n[3] Mehdi Sajjadi, Mehran Javanmardi, and Tolga Tasdizen. Regularization with stochastic transformations and perturbations for deep semi-supervised learning. In NeurIPS, pages 1171–1179, 2016.   \n[4] Dong-Hyun Lee et al. Pseudo-label: The simple and efficient semi-supervised learning method for deep neural networks. In Workshop on challenges in representation learning, ICML, volume 3, 2013.   \n[5] Geoffrey J McLachlan. Iterative reclassification procedure for constructing an asymptotically optimal rule of allocation in discriminant analysis. Journal of the American Statistical Association, 70(350):365–369, 1975.   \n[6] Chuck Rosenberg, Martial Hebert, and Henry Schneiderman. Semi-supervised self-training of object detection models. 2005.   \n[7] Henry Scudder. Probability of error of some adaptive pattern-recognition machines. IEEE Transactions on Information Theory, 11(3):363–371, 1965.   \n[8] Qizhe Xie, Minh-Thang Luong, Eduard Hovy, and Quoc V Le. Self-training with noisy student improves imagenet classification. In CVPR, pages 10687–10698, 2020.   \n[9] Antti Rasmus, Harri Valpola, Mikko Honkala, Mathias Berglund, and Tapani Raiko. Semisupervised learning with ladder networks. In NeurIPS, pages 3546–3554, 2015.   \n[10] Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In NeurIPS, pages 1195– 1204, 2017.   \n[11] Qizhe Xie, Zihang Dai, Eduard Hovy, Thang Luong, and Quoc Le. Unsupervised data augmentation for consistency training. NeurIPS, 33, 2020.   \n[12] David Berthelot, Nicholas Carlini, Ian Goodfellow, Nicolas Papernot, Avital Oliver, and Colin Raffel. Mixmatch: A holistic approach to semi-supervised learning. NeurIPS, page 5050–5060, 2019.   \n[13] David Berthelot, Nicholas Carlini, Ekin D Cubuk, Alex Kurakin, Kihyuk Sohn, Han Zhang, and Colin Raffel. Remixmatch: Semi-supervised learning with distribution matching and augmentation anchoring. In ICLR, 2019.   \n[14] Kihyuk Sohn, David Berthelot, Nicholas Carlini, Zizhao Zhang, Han Zhang, Colin A Raffel, Ekin Dogus Cubuk, Alexey Kurakin, and Chun-Liang Li. Fixmatch: Simplifying semisupervised learning with consistency and confidence. NeurIPS, 33, 2020.   \n[15] Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In ICML, pages 41–48, 2009.   \n[16] Yves Grandvalet, Yoshua Bengio, et al. Semi-supervised learning by entropy minimization. In CAP, pages 281–296, 2005.   \n[17] Anastasia Pentina, Viktoriia Sharmanska, and Christoph H Lampert. Curriculum learning of multiple tasks. In CVPR, pages 5492–5500, 2015.   \n[18] Lu Jiang, Deyu Meng, Qian Zhao, Shiguang Shan, and Alexander Hauptmann. Self-paced curriculum learning. In AAAI, volume 29, 2015.   \n[19] Alex Graves, Marc G Bellemare, Jacob Menick, Remi Munos, and Koray Kavukcuoglu. Automated curriculum learning for neural networks. In ICML, pages 1311–1320. PMLR, 2017.   \n[20] Guy Hacohen and Daphna Weinshall. On the power of curriculum learning in training deep networks. In ICML, pages 2535–2544. PMLR, 2019.   \n[21] Daphna Weinshall, Gad Cohen, and Dan Amir. Curriculum learning by transfer learning: Theory and experiments with deep networks. In ICML, pages 5238–5246. PMLR, 2018.   \n[22] Eric Arazo, Diego Ortego, Paul Albert, Noel E O’Connor, and Kevin McGuinness. Pseudolabeling and confirmation bias in deep semi-supervised learning. In IJCNN, pages 1–8, 2020.   \n[23] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.   \n[24] Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. 2011.   \n[25] Adam Coates, Andrew $\\mathrm { N g }$ , and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In AISTATS, pages 215–223, 2011.   \n[26] 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. Ieee, 2009.   \n[27] Avital Oliver, Augustus Odena, Colin Raffel, Ekin D Cubuk, and Ian J Goodfellow. Realistic evaluation of deep semi-supervised learning algorithms. In NeurIPS, pages 3239–3250, 2018.   \n[28] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, high-performance deep learning library. NeurIPS, 32:8026–8037, 2019.   \n[29] Ilya Sutskever, James Martens, George Dahl, and Geoffrey Hinton. On the importance of initialization and momentum in deep learning. In ICML, pages 1139–1147. PMLR, 2013.   \n[30] Boris T Polyak. Some methods of speeding up the convergence of iteration methods. Ussr computational mathematics and mathematical physics, 4(5):1–17, 1964.   \n[31] Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. ICLR, 2016.   \n[32] Ekin D Cubuk, Barret Zoph, Jonathon Shlens, and Quoc V Le. Randaugment: Practical automated data augmentation with a reduced search space. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pages 702–703, 2020.   \n[33] 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.   \n[34] Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. In BMVC, 2016.   \n[35] Tianyi Zhou, Shengjie Wang, and Jeff Bilmes. Time-consistent self-supervision for semisupervised learning. In ICML, pages 11523–11533. PMLR, 2020.   \n[36] Mamshad Nayeem Rizve, Kevin Duarte, Yogesh S Rawat, and Mubarak Shah. In defense of pseudo-labeling: An uncertainty-aware pseudo-label selection framework for semi-supervised learning. arXiv preprint arXiv:2101.06329, 2021.   \n[37] Chen Gong, Dacheng Tao, Stephen J Maybank, Wei Liu, Guoliang Kang, and Jie Yang. Multimodal curriculum learning for semi-supervised image classification. IEEE Transactions on Image Processing, 25(7):3249–3260, 2016.   \n[38] Hoel Kervadec, Jose Dolz, Éric Granger, and Ismail Ben Ayed. Curriculum semi-supervised segmentation. In International Conference on Medical Image Computing and Computer-Assisted Intervention, pages 568–576. Springer, 2019.   \n[39] Qing Yu, Daiki Ikami, Go Irie, and Kiyoharu Aizawa. Multi-task curriculum framework for open-set semi-supervised learning. In ECCV, pages 438–454. Springer, 2020.   \n[40] Yue Han, Yuhong Liu, and Zhigang Jin. Sentiment analysis via semi-supervised learning: a model based on dynamic threshold and multi-classifiers. Neural Computing and Applications, 32(9):5117–5129, 2020.   \n[41] Zhedong Zheng and Yi Yang. Rectifying pseudo label learning via uncertainty estimation for domain adaptive semantic segmentation. IJCV, 129(4):1106–1120, 2021.   \n[42] Paola Cascante-Bonilla, Fuwen Tan, Yanjun Qi, and Vicente Ordonez. Curriculum labeling: Revisiting pseudo-labeling for semi-supervised learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 35, pages 6912–6920, 2021. ",
+        "bbox": [
+            173,
+            304,
+            826,
+            916
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            50,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            416
+        ],
+        "page_idx": 11
+    }
+]

parse/train/86NHK__yFDl/86NHK__yFDl_content_list.json

@@ -0,0 +1,1641 @@
+[
+    {
+        "type": "text",
+        "text": "TTT++: When Does Self-Supervised Test-Time Training Fail or Thrive? ",
+        "text_level": 1,
+        "bbox": [
+            281,
+            122,
+            718,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yuejiang Liu Parth Kothari Bastien van Delft ",
+        "bbox": [
+            308,
+            224,
+            694,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Baptiste Bellot-Gurlet Taylor Mordan Alexandre Alahi ",
+        "text_level": 1,
+        "bbox": [
+            287,
+            256,
+            705,
+            272
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "École Polytechnique Fédérale de Lausanne (EPFL) ",
+        "bbox": [
+            328,
+            285,
+            665,
+            299
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{firstname.lastname}@epfl.ch ",
+        "bbox": [
+            379,
+            306,
+            619,
+            319
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            356,
+            535,
+            372
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Test-time training (TTT) through self-supervised learning (SSL) is an emerging paradigm to tackle distributional shifts. Despite encouraging results, it remains unclear when this approach thrives or fails. In this work, we first provide an indepth look at its limitations and show that TTT can possibly deteriorate, instead of improving, the test-time performance in the presence of severe distribution shifts. To address this issue, we introduce a test-time feature alignment strategy utilizing offline feature summarization and online moment matching, which regularizes adaptation without revisiting training data. We further scale this strategy in the online setting through batch-queue decoupling to enable robust moment estimates even with limited batch size. Given aligned feature distributions, we then shed light on the strong potential of TTT by theoretically analyzing its performance post adaptation. This analysis motivates our use of more informative self-supervision in the form of contrastive learning for visual recognition problems. We empirically demonstrate that our modified version of test-time training, termed $T T T + +$ , outperforms state-of-the-art methods by significant margins on several benchmarks. Our result indicates that storing and exploiting extra information, in addition to model parameters, can be a promising direction towards robust test-time adaptation. Our code is available at https://github.com/vita-epfl/ttt-plus-plus. ",
+        "bbox": [
+            232,
+            387,
+            766,
+            637
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            665,
+            310,
+            683
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Machine learning models often struggle to generalize under distribution shifts. Even a perceptually mild shift between training and test data, e.g., JPEG compression, may cause severe prediction errors [1]. One popular family of methods to address this challenge is to learn an invariant representation across domains by making use of labelled training data and unlabelled test data simultaneously [2–5]. However, revisiting training data at test time can be impractical due to increasing privacy concerns, inflating sizes of datasets as well as many other real-world constraints. This shortcoming prompts a more challenging yet appealing test-time adaptation paradigm: given a trained model, how can we adapt it from one domain to another on the fly, without access to training data and human annotations? ",
+        "bbox": [
+            174,
+            698,
+            825,
+            809
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One promising approach towards this goal is test-time training (TTT) through self-supervision [6]. The key idea of TTT is simple and straightforward: train the model on two tasks, namely a main task and a self-supervised learning (SSL) task, and update the model based only on the SSL task at test time. This technique implemented with self-supervised rotation prediction has shown encouraging results for improving the robustness of image classifiers under a variety of distributional shifts. Yet, its empirical performance is still inferior to other families of test-time algorithms [7, 8]. ",
+        "bbox": [
+            174,
+            815,
+            825,
+            898
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we first take an in-depth look at TTT with emphasis on its limitations. Our analysis starts with a basic question: can TTT always mitigate the effects of distributional shifts? Through an illustrative problem, we show that the TTT framework can lead to surprising failures, deteriorating the test accuracy rather than improving it. This problem is largely attributed to the unconstrained update from the SSL task that interfere with the main task. To address this issue, we introduce a test-time feature alignment strategy by means of offline feature summarization and online moment matching: once training completes, we compute the mean and covariance matrix of training features and store them as part of the model, referred to as offline feature summarization; at test time, we encourage the test feature distribution to be close to the training one by matching the moments estimated online with those pre-computed offline, a process referred to as online moment matching. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            229
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "One practical challenge for online feature alignment lies in scaling the strategy to problems with a large number of classes, as obtaining a robust estimate of moments often requires at least a handful of samples per class. To mitigate this issue, we draw inspiration from recent literature [9] and decouple the sample size from the batch size for moment estimates. Specifically, we maintain a large dynamic queue of encoded features and progressively update it in a mini-batch manner. This modification enables effective feature alignment even with limited batch size, greatly improving its viability in the online test-time setting. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, we shed light on the strong potential of TTT through a theoretical analysis of the test accuracy after adaptation. In particular, we derive a lower bound of the test accuracy on the main task and show that it is expected to grow rapidly when the SSL task gets closer to the main task. These findings motivate our integration of contrastive representation learning [9–12], as a strong instance of SSL, into the TTT framework in visual recognition problems. ",
+        "bbox": [
+            174,
+            339,
+            825,
+            409
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "By combining the three proposed components, we devise an improved version of test-time training, termed $T T T + +$ . Experimental results show that $\\mathrm { T T T } { + } { + }$ significantly outperforms other recent methods by significant margins on various robustness benchmarks. Our results suggest that exploiting extra information, including both task-specific information in the form of strong self-supervision and domain-specific information in the form of feature summarization, can be a promising direction to enhance the effectiveness of test-time adaptation. ",
+        "bbox": [
+            174,
+            415,
+            825,
+            498
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            516,
+            308,
+            534
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            546,
+            310,
+            561
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Test-time Adaptation. Adapting machine learning models based on test samples has garnered growing interests in both generative problems such as super-resolution [13], image synthesis [14] and image manipulation [15], and discriminative problems like image classification [16]. Our work is focused on the latter one in the presence of distributional shifts. Several recent works [16, 17] have shown the advantage of adapting the learned classifier to new test domains in the unsupervised manner, without revisiting the source data. One simplest form is to replace the batch-norm statistics estimated on the training set with those on test examples [17]. Another line of work proposed to adapt the model parameters by exploiting the predicted labels on test examples, such as entropy minimization [8] and pseudo-labeling [7]. While these methods yield promising results on some benchmarks, they are inherently restricted to classification problems and often vulnerable under large distribution shifts [18]. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            724
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "More closely related to ours, [6] proposed test-time training through self-supervised learning, e.g., predicting the type of image rotations. This approach does not involve any assumptions about the output for the main task and is therefore more generic. It has been successfully applied to a variety of problems, such as instance tracking [19] and reinforcement learning [20]. Nevertheless, it was shown empirically inferior to other test-time algorithms [8]. Our work provides an in-depth analysis of its limitations, introduces simple yet effective remedies, and consolidates more theoretical grounds. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            814
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Feature Alignment. Aligning the distributions of training and test samples in the feature space is commonly used for domain adaptation. Previous feature alignment methods fall into two main categories: minimizing a divergence measure, such as MMD [21], Coral [22] and CMD [23], or encouraging the domain confusion through adversarial training [5, 24]. However, most of these methods rely on the co-existence of source and target data, and thus cannot be readily applied to the test-time setting where source data is not available. Our work revisits the critical role of feature alignment for test-time training and proposes a simple and practical strategy that enables online feature alignment, even with a limited batch size. ",
+        "bbox": [
+            174,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/49555e73b0972014318945893eddae60aef8e69f8b8ce78ab43ffe1aac9d1fec.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of a failure case where TTT hurts robustness under distributional shifts. (a) The predictive model reaches high accuracy on both the main classification task, i.e., separating red and blue data points, and the auxiliary self-supervised task, i.e., separating circles and crosses, in the training domain. (b) Given a large distributional shift, test samples are encoded into a new subspace, resulting in limited accuracy on both tasks. (c) Without any constraints on the feature distribution, TTT may result in an updated encoder severely overfitting to the SSL task, and consequently deteriorate the accuracy on the main task, as opposed to improving it. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            88,
+            812,
+            195
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            306,
+            823,
+            335
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Self-Supervised Learning. Self-supervised learning is a powerful paradigm to learn rich representations from unlabeled samples. Stunning progress has been made in recent years by designing informative self-supervised tasks [11, 12, 25–28] and stabilizing the training process [9, 29]. Prior works are mainly focused on unsupervised pre-training, whereas our work looks into the importance of incorporating strong self-supervised learning methods for test-time adaptation. ",
+        "bbox": [
+            173,
+            353,
+            825,
+            424
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Preliminary: Test-Time Training ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            444,
+            442,
+            459
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Test-time training (TTT) [6] is a general framework for adapting neural network models to a new test distribution based on unlabeled samples. Different from the conventional approach that trains the model only on the task of interest, TTT considers two tasks: a main task and an auxiliary SSL task. The model is trained on both tasks simultaneously with a multi-task architecture composed of one shared encoder $g$ and two separate heads $\\pi _ { m }$ and $\\pi _ { s }$ respectively. Given a labeled training dataset $D = \\{ ( x _ { i } , y _ { i } ) \\} _ { i \\in \\{ 1 , . . . , N \\} }$ , the model is trained to minimize two losses jointly: ",
+        "bbox": [
+            173,
+            470,
+            826,
+            556
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9acf85b888b24165b7eebc3fb93cba8f32f0390e3539d193e581bbc5ac38ab1e.jpg",
+        "text": "$$\n\\mathcal { L } _ { t r a i n } ( D ; g , \\pi _ { m } , \\pi _ { s } ) = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\mathcal { L } _ { m } ( x _ { i } , y _ { i } ; g , \\pi _ { m } ) + \\lambda \\mathcal { L } _ { s } ( x _ { i } ; g , \\pi _ { s } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            566,
+            720,
+            611
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda$ is a hyper-parameter to balance the two tasks. ",
+        "bbox": [
+            173,
+            621,
+            531,
+            636
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the presence of distributional shifts, the learned model often struggles to directly generalize to a new test set $D ^ { \\prime } = \\{ x _ { i } ^ { \\prime } \\} _ { i \\in \\{ 1 , \\dots , N ^ { \\prime } \\} }$ . The core idea of TTT is to fine-tune the encoder $g$ based on the self-supervised task with the test examples, ",
+        "bbox": [
+            174,
+            640,
+            825,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7ec471b2c465a59644344219bba2d049d16b2df08cd7ca6e5a4307a664ea9810.jpg",
+        "text": "$$\n\\mathcal { L } _ { T T T } ( D ^ { \\prime } ; g ^ { \\prime } ) = \\frac { 1 } { N ^ { \\prime } } \\sum _ { i = 1 } ^ { N ^ { \\prime } } \\mathcal { L } _ { s } ( x _ { i } ^ { \\prime } ; g ^ { \\prime } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            694,
+            619,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "with the hope that the updated model $\\pi _ { m } \\circ g ^ { \\prime }$ yields improved results on the main task. ",
+        "bbox": [
+            173,
+            748,
+            740,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "TTT instantiated with a self-supervised rotation prediction task has been demonstrated effective for improving the robustness of image classifiers under common distributional shifts [6]. However, it was shown inferior to other families of test-time adaptation methods [7, 8]. We will next look into its strengths and limitations, and propose an improved version for better adaptation performance. ",
+        "bbox": [
+            173,
+            768,
+            825,
+            827
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 When Does Test-Time Training Fail? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            848,
+            513,
+            867
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first throw light on a caveat of test-time training under large distributional shifts, and subsequently introduce practical solutions tailored for the test-time setting. ",
+        "bbox": [
+            173,
+            882,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/8930dc31a5b8e501e73b9a0a672fb5fb90a6a9249aa230e9aab6fe00b5f22654.jpg",
+        "image_caption": [
+            "Figure 2: Our modified version of test-time training $\\mathrm { ( T T T + + ) }$ ). Our method consists of three stages: model training, offline feature summarization, and online test-time adaptation. (i) During training, the model is optimized for the main task and an auxiliary contrastive self-supervised task jointly. (ii) Once training completes, we summarize the feature distributions after the encoder and the self-supervised head in the form of first and second-order moments. (iii) At test time, we adapt the encoder through online feature alignment (Sec. 3.2) and self-supervised learning (Sec. 4.2). In case of limited batch size, we maintain a large dynamic queue of feature vectors for robust moment estimates (Sec. 3.3). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            93,
+            813,
+            292
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Illustrative Example of Failures ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            410,
+            433,
+            425
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One implicit assumption behind TTT is that the encoder update based on SSL can counter the effect of the underlying distributional shift on the main task. This assumption, however, is likely broken under large shifts and results in unexpected adaptation failures. To illustrate this limitation, we introduce a simple toy problem in Figure 1, where the main task and the SSL task are defined as classifying colors and symbols of encoded features in the 2-dimensional latent space. We consider an ideal scenario where the two tasks are highly correlated such that a well-trained model can attain high accuracies on both of them in the training domain. Nevertheless, in the presence of a significant distributional shift, the model may still suffer from substantial prediction errors in the test domain. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            547
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this scenario, while TTT may restore the discriminative power of the learned representation for the main task to a certain degree, the unconstrained self-supervised adaptation may yield severe overfitting to the auxiliary SSL task. As a consequence, the performance on the main task can even deteriorate as opposed to improving. This phenomenon is not restricted to our illustration and also occurs in practice, as shown in Section 5.1. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            623
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Online Feature Alignment ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            638,
+            395,
+            654
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As illustrated in the toy example above, simply applying self-supervised adaptation at test time can lead to arbitrarily poor results. To address this issue, we introduce an online feature alignment strategy to ensure robust adaptation at test time. The core idea of our strategy is to impose a constraint over the feature space during TTT such that the feature distribution of test examples remains close to that in the training domain. While some feature alignment techniques such as MMD [2] and adversarial training [24] have been widely used for domain adaptation, they often rely on sampling from training and test domains concurrently, which is impractical in the test-time setting. We, therefore, turn to classical divergence measures that can be estimated independently for each distribution. More specifically, we use the square distance of the first and second moments between two feature distributions, inspired by DDC [30] and Coral [22], to approximate the domain discrepancy. This design choice allows us to summarize the distribution of training features in a compact format and store it as part of the model, eliminating the need to revisit the training data during test-time adaptation. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            830
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Concretely, once training completes, we perform an offline feature summarization step that characterizes the disempirical mean ure vectors in the trainiand covariance matrix $Z = \\{ z _ { 1 } ^ { T } , \\dots , z _ { N } ^ { T } \\}$ h the. The $\\begin{array} { r } { \\mu _ { z } = \\frac { 1 } { N } \\sum _ { i } ^ { N } z _ { i } } \\end{array}$ $\\begin{array} { r } { \\Sigma _ { Z } = \\frac { 1 } { N - 1 } \\big ( Z ^ { T } Z - ( I ^ { T } Z ) ^ { T } ( I ^ { T } Z ) \\big ) } \\end{array}$ former is essentially equivalent to the channel-wise batch normalization statistics while the latter is more informative yet light-weight for computation and storage. At test time, we regularize the self-supervised adaptation by minimizing the distance between the feature statistics estimated from a mini-batch of test samples, i.e., $\\mu _ { z } ^ { \\prime }$ and $\\Sigma _ { z } ^ { \\prime }$ , and the pre-stored quantities about the training domain: ",
+        "bbox": [
+            174,
+            837,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f873448714370a224b854a417f52c8551d1349d3d47cd5f8ce06ad194503e042.jpg",
+        "text": "$$\n\\mathcal { L } _ { f , z } = \\left\\| \\mu _ { z } - \\mu _ { z } ^ { \\prime } \\right\\| _ { 2 } ^ { 2 } + \\left\\| \\Sigma _ { z } - \\Sigma _ { z } ^ { \\prime } \\right\\| _ { F } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            122,
+            620,
+            143
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\lVert \\cdot \\rVert _ { 2 }$ is the Euclidean norm and $\\left\\| \\cdot \\right\\| _ { F }$ is the Frobenius norm. ",
+        "bbox": [
+            173,
+            145,
+            607,
+            161
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The basic form of online moment matching can be limiting in that the low-order statistics may be insufficient to fully capture complex distributions in high dimensions, e.g., 2048 for the standard ResNet-50. To alleviate this issue, we align the feature distributions at both the output of the encoder and the output of the self-supervised head, which are of lower dimensions, e.g., 128 in the case of contrastive learning described in Sec. 4.2. Our final objective at test time is a weighted combination of the self-supervised loss $\\mathcal { L } _ { s }$ , the feature alignment loss at the encoder $\\mathcal { L } _ { f , z }$ and that at the self-supervised head $\\mathcal { L } _ { f , s }$ , ",
+        "bbox": [
+            173,
+            165,
+            825,
+            265
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f42785eabe4c02358e1f26d3154a47c68c8d694c0da197e1018747c9d7d1c521.jpg",
+        "text": "$$\n\\mathcal { L } _ { T T T + + } = \\mathcal { L } _ { s } + \\lambda _ { z } \\mathcal { L } _ { f , z } + \\lambda _ { s } \\mathcal { L } _ { f , s } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            267,
+            619,
+            284
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda _ { z }$ and $\\lambda _ { s }$ are hyper-parameters controlling the emphasis on each term. ",
+        "bbox": [
+            174,
+            285,
+            681,
+            300
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Online Dynamic Queue ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            315,
+            377,
+            330
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "One practical challenge for online feature alignment lies in scaling the strategy to problems having large numbers of classes. Intuitively, a good estimate of moments of the entire distribution needs at least a handful of samples per class. As a consequence, the demand for sample size grows linearly with the number of classes, for instance, over $\\mathord { \\sim } 1 0 0 0$ samples are required in the case of CIFAR-100. However, the computational resources during deployment are often limited to accommodate such a large batch size in the test-time setting. ",
+        "bbox": [
+            173,
+            340,
+            825,
+            424
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To overcome this challenge, we draw inspiration from recent literature [9] and maintain a dynamic queue of encoded features to decouple the batch size from the sample size for moment estimates. More specifically, we construct a dynamic queue that contains a few batches of feature vectors encoded at test time. We progressively update the queue by appending the latest mini-batch and popping out the oldest one, as illustrated in Figure 2. This batch-queue decoupling allows us to collect a large and consistent pool of samples for online moment matching, even with a very limited batch size. ",
+        "bbox": [
+            173,
+            430,
+            825,
+            527
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "By integrating the online moment matching and batch-queue decoupling, our test-time algorithm takes into account both the discriminative power and the marginal distribution of the updated representations, enabling more robust adaptation under various settings. It is worth noting that the current moment matching strategy is just a particular instance of the online feature alignment scheme. It can be naturally extended to incorporate higher-order statistics [23, 31] to bring further performance gain at the cost of larger space and computational complexities. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            617
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 When Does Test-Time Training Thrive? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            635,
+            537,
+            652
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given properly aligned feature distribution, we next look into the potential of test-time training given strong SSL tasks. We first derive a lower bound of the test accuracy in general scenarios and then analyze it in a specific setup where the performance on the main task can be directly estimated. These analyses motivate our use of more informative self-supervised learning for test-time training. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            722
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Theoretical Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            737,
+            348,
+            752
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We consider a training set comprised of samples drawn from the joint distribution $\\mathbb { P } _ { X , Y _ { m } , Y _ { s } }$ , where $X , Y _ { m }$ and $Y _ { s }$ are random variables corresponding to the training samples, the main task labels and the self-supervised labels respectively. Similarly, the test set consists of samples drawn from the joint distribution $\\mathbb { P } _ { X ^ { \\prime } , Y _ { m } ^ { \\prime } , Y _ { s } ^ { \\prime } }$ . In the presence of distribution shift, $\\mathbb { P } _ { X , Y _ { m } , Y _ { s } }$ and $\\mathbb { P } _ { X ^ { \\prime } , Y _ { m } ^ { \\prime } , Y _ { s } ^ { \\prime } }$ are not identical. However, we make the following assumption about label distribution in our analysis. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assumption 1. The training and test labels are equal in distribution, $Y _ { m } \\ { \\overset { d } { = } } \\ Y _ { m } ^ { \\prime }$ , $Y _ { s } \\ { \\overset { d } { = } } \\ Y _ { s } ^ { \\prime }$ and $( Y _ { m } , Y _ { s } ) \\overset { d } { = } ( Y _ { m } ^ { \\prime } , Y _ { s } ^ { \\prime } ) .$ . ",
+        "bbox": [
+            174,
+            837,
+            825,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In addition, we restrict our analysis to the scenarios where both two tasks can be solved perfectly during training. ",
+        "bbox": [
+            174,
+            882,
+            821,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assumption 2. There exist an encoder g and classifiers $\\pi _ { m }$ and $\\pi _ { s }$ such that $\\mathbb { P } ( \\pi _ { m } ( g ( X ) ) = Y _ { m } ) =$ 1 and $\\bar { \\mathbb { P } } ( \\pi _ { s } ( g ( X ) ) = Y _ { s } ) = 1$ . ",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "During TTT, the shared encoder $g$ is updated to $g ^ { \\prime }$ such that the self-supervised head $\\pi _ { s }$ fits the test data. Given our proposed online feature alignment in Equation 4, we assume the encoded features in the training and test domains, i.e., $Z$ and $Z ^ { \\prime }$ , have the following property. ",
+        "bbox": [
+            174,
+            128,
+            821,
+            171
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Assumption 3. The marginal feature distribution and the conditional feature distributions at test time are aligned with their counterparts during training, that is, $Z { \\overset { d } { = } } Z ^ { \\prime }$ and $( Z \\mid Y _ { s } = k ) \\overset { d } { = } ( Z ^ { \\prime } \\mid$ $Y _ { s } ^ { \\prime } = k$ ) for all classes $k$ in the SSL task. ",
+        "bbox": [
+            173,
+            172,
+            825,
+            220
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "nder these assumptions, we consider the outcome of test-time training in the worst-case scena ",
+        "bbox": [
+            194,
+            229,
+            794,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. The prediction accuracy on the main task is lower bounded: ",
+        "bbox": [
+            173,
+            247,
+            673,
+            262
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9c3b58b7a31c893d088cd08dfdaf1a80cb1520392badfe4f67b93b0703da13ca.jpg",
+        "text": "$$\n{ \\mathbb { P } } ( \\pi _ { m } ( Z ^ { \\prime } ) = Y _ { m } ^ { \\prime } ) \\geq \\sum _ { y _ { s } } { \\mathbb { P } } ( Y _ { s } = y _ { s } ) \\operatorname* { m a x } \\left\\{ 0 , 2 \\left( \\operatorname* { m a x } _ { y _ { m } } { \\mathbb { P } } ( Y _ { m } = y _ { m } \\mid Y _ { s } = y _ { s } ) - 0 . 5 \\right) \\right\\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            263,
+            784,
+            304
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proof. Please refer to Section A.1 in the supplementary material. ",
+        "bbox": [
+            173,
+            315,
+            601,
+            332
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 highlights the importance of the relation between the main task and the SSL task for the test accuracy after adaptation. More specifically, the SSL task needs to be informative with respect to the main task to guarantee the performance, i.e., knowing the SSL class $y _ { s }$ makes a main class $y _ { m }$ highly probable, or equivalently $\\mathbb { P } ( Y _ { m } = y _ { m } \\mid Y _ { s } = y _ { s } )$ is large, leading to a greater lower bound. ",
+        "bbox": [
+            173,
+            344,
+            825,
+            402
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To further understand the impact of the task relation on test-time training, we next consider a particular setting, where the encoded features fully overfit to the SSL task (e.g., lengthy test-time training) and become independent of the main task label given the SSL label. Under this condition, the prediction accuracy on the main task can be directly estimated as follows. ",
+        "bbox": [
+            174,
+            407,
+            825,
+            463
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2. If $Z ^ { \\prime } \\perp \\perp Y _ { m } ^ { \\prime } \\mid Y _ { s } ^ { \\prime }$ , then the prediction accuracy on the main task is given by ",
+        "bbox": [
+            171,
+            465,
+            753,
+            482
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1e138530c63f1c656a94ed2359d29d1f114c78d146dcbc02cef102f1f37cdab9.jpg",
+        "text": "$$\n\\mathbb { P } \\big ( \\pi _ { m } ( Z ^ { \\prime } ) = Y _ { m } ^ { \\prime } \\big ) = \\sum _ { y _ { s } } \\left[ \\mathbb { P } \\big ( Y _ { s } = y _ { s } \\big ) \\sum _ { y _ { m } } \\mathbb { P } \\big ( Y _ { m } = y _ { m } \\mid Y _ { s } = y _ { s } \\big ) ^ { 2 } \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            483,
+            730,
+            527
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proof. Please refer to Section A.2 in the supplementary material. ",
+        "bbox": [
+            173,
+            549,
+            601,
+            565
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, if the encoded features do not contain more information than the SSL labels about the main task, the accuracy of the main classifier $\\pi _ { m }$ only depends on the property of the SSL task. In particular, the square term on the right-hand side of Equation 6 emphasizes the paramount importance of designing a closely related SSL task. When the two tasks diverge, the test accuracy drops quadratically fast, leading to ineffective adaptation. ",
+        "bbox": [
+            173,
+            578,
+            825,
+            648
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Test-Time Training through Contrastive Learning ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            662,
+            562,
+            679
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our theoretical analysis above reveals the importance of incorporating an SSL task highly correlated with the main task for test-time training. One practical way to quantify the relation between two tasks is to measure the transferability of the representation learned from one task to another [32]. Given the remarkable results of contrastive methods for visual representation pre-training [9, 12, 33, 34], we hypothesize that they would also be suitable choices for test-time training. We thus replace the rotation prediction task with SimCLR [12] in the context of visual recognition. Given a mini-batch of $B$ images, we augment each image to two views. We consider the two augmented views from the same original instance as a positive pair and treat the other pairs as negative ones. The feature vector $z _ { i } = g ( \\bar { x } _ { i } )$ of each image $x _ { i }$ is projected to a lower-dimensional space $h _ { i } = \\pi _ { s } ( z _ { i } )$ through our self-supervised head. The projected hidden embeddings from a positive pair $< h _ { i } , h _ { j } >$ are encouraged to be closer than those from the negative ones through the following loss, ",
+        "bbox": [
+            173,
+            689,
+            826,
+            842
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d30df020487e7c87ef8d7d9a007e040b1ab29a200a9335ac1620059e7802c7fd.jpg",
+        "text": "$$\n\\mathcal { L } _ { s } = - \\log \\frac { \\exp ( \\sin ( h _ { i } , h _ { j } ) / \\tau ) } { \\sum _ { k = 1 } ^ { 2 B } \\mathbb { 1 } _ { k \\neq i } \\exp ( \\sin ( h _ { i } , h _ { k } ) / \\tau ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            844,
+            647,
+            882
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\tau$ is a temperature scaling parameter. The distance between projected embeddings is measured by cosine similarity $\\mathrm { s i m } ( u , v ) \\stackrel { \\smile } { = } u ^ { T } v / ( \\| u \\| \\| v \\| )$ . ",
+        "bbox": [
+            171,
+            883,
+            821,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/b258d7d56fd2e524deaf6ae186df756c0ecc77fdebea679f186d8fa15cc0ba63.jpg",
+        "image_caption": [
+            "Figure 3: Qualitative comparison of TTT [6] and our $\\mathrm { T T } \\mathrm { + + }$ on the inter-twinning moons problem in the presence of large translation and rotation shifts. The vanilla TTT drives the decision boundary further away from a desired one due to a severe feature misalignment, marked by the dashed arrow in the feature PCA visualization. In comparison, our method adapts the decision boundary to the test domain more effectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            89,
+            488,
+            223
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/eedd029d641f50f4d7869b375d40f329601e5c6b4ef9b357ee0f9702e78804f3.jpg",
+        "image_caption": [
+            "Figure 4: Quantitative comparison of TTT [6] and our $\\mathrm { T T } \\mathrm { + + }$ on the inter-twinning moons problem under 150 different setups. Standard deviations are visualized in shaded regions. Our method (left) is particularly advantageous under large shifts, i.e., low test accuracy before adaptation, and (right) greatly benefits from a higher correlation, i.e., larger label agreement, between the main and SSL tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            89,
+            815,
+            223
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            352,
+            312,
+            368
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We empirically validate our proposed method in four scenarios: synthetic toy problem, common image corruptions, natural domain shifts, and sim-to-real transfer. ",
+        "bbox": [
+            176,
+            385,
+            823,
+            412
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We consider the following baselines throughout our experiments: ",
+        "bbox": [
+            173,
+            420,
+            599,
+            434
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• Test: the model in the training domain is directly evaluated on the test data without any adaptation;   \n• Test-time normalization (BN) [35] updates the batch normalization statistics of the trained network according to the test data;   \n• Test-time entropy minimization (TENT) [8] updates the batch normalization statistics of the trained network by minimizing the entropy of the model predictions on the test data;   \n• Source Hypothesis Transfer (SHOT) [36] freezes the classifier module and updates only the feature extraction module by exploiting the concepts of information maximization and self-supervised pseudo-labeling during testing;   \n• Test-time training (TTT-R) [6] trains the network jointly on the main task and a rotation-based SSL task in the source domain; during test, TTT-R continues to train on the rotation-based task in the target domain. ",
+        "bbox": [
+            179,
+            438,
+            825,
+            594
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also evaluate the following ablated versions of our method: ",
+        "bbox": [
+            173,
+            598,
+            586,
+            613
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• Test-time feature alignment (TFA) aligns the first-order and second-order statistics of the source and target distributions during testing (Section 3.2 and 3.3);   \n• Test-time contrastive learning (TTT-C) trains the network jointly on the main task and a contrastive learning (SSL) task in the source domain; during test, TTT-C continues to update the encoder based on contrastive learning in the target domain (Section 4.2). ",
+        "bbox": [
+            179,
+            617,
+            825,
+            688
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The full version of our method, improved test-time training $\\mathbf { \\left( T T + \\right) }$ ), combines TFA and TTT-C. ",
+        "bbox": [
+            173,
+            691,
+            812,
+            707
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Synthetic Toy Problem ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            724,
+            370,
+            739
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We first evaluate our method on the inter-twinning moons problem [4, 37], where the main task is to predict the moon class of a given data point and the SSL task is to predict on which side of the hyperplane (i.e., linear separator between the two moons) the data point lies on. The relation (label agreement) between the two tasks depends on the separation distance between the two moons. To solve both tasks simultaneously, we build a small neural network that consists of a 2-layer MLP as the shared encoder and two 2-layer MLPs as separate task heads. Each hidden layer contains 8 neurons. The learned model attains over $9 9 \\%$ accuracy on both the main and SSL tasks in the training domain. We simulate a variety of distributional shifts through translation and rotation of all data points. ",
+        "bbox": [
+            173,
+            752,
+            825,
+            863
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows the decision boundaries and encoded features from the vanilla TTT and our proposed $\\mathrm { T T T } { + } { + }$ in a particular test case of large distributional shift. TTT not only fails to improve the classification accuracy but even pushes the decision boundary further away from a desired one due to the severe feature distribution mismatch, as evidenced in the PCA visualization. In comparison, our $\\mathrm { T T T } { + } { + }$ yields substantial performance gain, boosting the test accuracy from $50 \\%$ to $93 \\%$ , thanks to the reduced feature distributional shift enforced by the proposed online moment matching. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5b78b67372574a26d23bdc4877edb6553fcb4808dfa260a97a2698eb054419eb.jpg",
+        "image_caption": [
+            "Figure 5: Classification error $( \\% )$ on CIFAR10-C [1]. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            90,
+            526,
+            238
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/fe1d5892953a184f7726855d9e0a00211b162b550655d5e85e05d3472f5e124d.jpg",
+        "table_caption": [
+            "Table 1: Average classification error $( \\% )$ on CIFAR10-C/100-C [1] and CIFAR10.1 [40] "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>C10-C</td><td>C100-C</td><td>C10.1</td></tr><tr><td>Test</td><td>29.1</td><td>61.2</td><td>12.1</td></tr><tr><td>BN [41]</td><td>15.7</td><td>43.3</td><td>14.1</td></tr><tr><td>TTT-R [6]</td><td>14.3</td><td>40.4</td><td>11.0</td></tr><tr><td>SHOT [36]</td><td>14.7</td><td>38.1</td><td>11.1</td></tr><tr><td>TENT [8]</td><td>12.6</td><td>36.3</td><td>13.4</td></tr><tr><td>TFA (Ours)</td><td>11.9</td><td>35.8</td><td>12.1</td></tr><tr><td>TTT-C (Ours)</td><td>10.7</td><td>36.9</td><td>9.7</td></tr><tr><td>TTT++ (Ours)</td><td>9.8</td><td> 34.1</td><td>9.5</td></tr></table>",
+        "bbox": [
+            545,
+            123,
+            820,
+            256
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            279,
+            821,
+            320
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 summarizes the quantitative results of our methods as well as the vanilla counterpart under 150 different simulated setups. As shown on the left graph, when the domain shift only causes mild test errors on the main task, both the original TTT and our $\\mathrm { T T T } { \\cdot } + +$ yield strong adaptation results. However, the effectiveness of TTT deteriorates quickly along with the growth of domain shift, as reflected on the lower test accuracy. In comparison, our proposed $\\mathrm { T T T } { + } { + }$ demonstrates clear advantages under large shifts, e.g., when the test accuracy before adaptation is around 0.5. We further examine the impact of the relation between the main and SSL tasks on the adaptation performance by varying the separation distance between the two moons. The simulation results confirm the high potential of test-time training given improved SSL tasks, as analyzed in Section 4.1. ",
+        "bbox": [
+            174,
+            327,
+            825,
+            452
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 Common Image Corruption ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            468,
+            408,
+            483
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We further assess the robustness of our method against common image corruptions. Following the evaluation protocol of previous work [8], we train ResNet-50 [38] on CIFAR10/CIFAR100 [39] and test it on the CIFAR10-C/CIFAR100-C [1] datasets, which contain 15 types of algorithmically generated corruptions, such as noise, blur and snow effects. We use a batch size of 256 for test-time adaptation. In addition, we use a dynamic queue containing 16 batches of feature vectors for online feature alignment on CIFAR100-C. ",
+        "bbox": [
+            173,
+            493,
+            825,
+            577
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 shows the quantitative results under each type of image corruption. The average results on CIFAR10-C and CIFAR100-C are reported in Table 1. Our $\\mathrm { T T T } { + } { + }$ clearly outperforms the prior state-of-the-art test-time methods on CIFAR10-C and CIFAR100-C. In particular, incorporating a strong self-supervision task (TTT-C) already suffices to perform on par or better than TENT. Adding test-time feature alignment (TFA) on top of that yields an additional $\\sim 8 \\%$ relative reduction in terms of the test error. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            666
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 Natural Domain Shift ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            683,
+            364,
+            698
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We next demonstrate the efficacy of our method $\\mathrm { T T T } { + } { + }$ to tackle natural distribution shifts. We again use the pre-trained ResNet-50 and test it on CIFAR10.1 [40], a recently collected test set subject to natural distributional shift. Despite its high perceptual similarity with the CIFAR10 dataset, the CIFAR10.1 typically leads to a drop of accuracy $4 \\%$ to $10 \\%$ ) for a wide range of deep models [40]. ",
+        "bbox": [
+            174,
+            709,
+            825,
+            765
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 1 summarizes the results of various test-time algorithms on CIFAR10.1. Previous batch-normbased methods perform poorly and even degrade model accuracy. This phenomenon is tied to their implicit assumption that different samples and spatial locations are shifted in a similar manner [18], which is true for algorithmically generated image corruptions but does not hold on CIFAR-10.1. In contrast, $\\mathrm { T T T } { + } { + }$ is more generic and yields stronger performance under the natural distribution shift. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            840
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 Sim-to-Real Transfer ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            857,
+            361,
+            872
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We finally validate the effectiveness of our method on the VisDA-C dataset [42], a challenging large-scale benchmark of synthetic-to-real object classification. As shown in Table 2, prior methods that are fairly competitive under image corruptions, such as BN [41] and TENT [8], are not effective on VisDA-C. We conjecture that this is attributed to their strong restrictions over the adaptable parameters at test time. In contrast, our proposed method is more flexible, allows the model to update the entire encoder, and thus achieves compelling results on VisDA-C. Furthermore, the test-time feature alignment plays a crucial role in this synthetic-to-real domain adaptation problem, providing $\\sim 1 3 \\%$ performance boost on top of the TTT-C. ",
+        "bbox": [
+            174,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/a63afdc8f0cf109a1e5d996cbdcc9202757891bd2724e428248501833154dffe.jpg",
+        "table_caption": [
+            "Table 2: Classification error $( \\% )$ on the large-scale VisDA-C dataset [42]. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>plane</td><td>bcycl</td><td>bus</td><td>car</td><td>horse</td><td>knife</td><td>mcycl</td><td>person</td><td>plant</td><td>sktbrd</td><td>train</td><td>truck</td><td>Per-class</td></tr><tr><td>Test</td><td>56.52</td><td>88.71</td><td>62.77</td><td>30.56</td><td>81.88</td><td>99.03</td><td>17.53</td><td>95.85</td><td>51.66</td><td>77.86</td><td>20.44</td><td>99.51</td><td>58.72</td></tr><tr><td>BN [41]</td><td>44.38</td><td>56.98</td><td>33.24</td><td>55.28</td><td>37.45</td><td>66.60</td><td>16.55</td><td>59.02</td><td>43.55</td><td>60.72</td><td>31.07</td><td>82.98</td><td>48.12</td></tr><tr><td>TENT [8]</td><td>13.43</td><td>77.98</td><td>20.17</td><td>48.15</td><td>21.72</td><td>82.45</td><td>12.37</td><td>35.78</td><td>21.06</td><td>76.41</td><td>34.11</td><td>98.93</td><td>42.73</td></tr><tr><td>SHOT [36]</td><td>5.73</td><td>13.64</td><td>23.33</td><td>42.69</td><td>7.93</td><td>86.99</td><td>19.17</td><td>19.97</td><td>11.63</td><td>11.09</td><td>15.06</td><td>43.26</td><td>25.04</td></tr><tr><td>TFA (Ours)</td><td>28.25</td><td>32.03</td><td>33.67</td><td>64.77</td><td>20.49</td><td>56.63</td><td>22.52</td><td>36.30</td><td>24.84</td><td>35.20</td><td>25.31</td><td>64.24</td><td>39.58</td></tr><tr><td>TTT-C (Ours)</td><td>5.46</td><td>32.23</td><td>25.42</td><td>37.03</td><td>7.84</td><td>85.20</td><td>9.14</td><td>23.80</td><td>11.72</td><td>11.00</td><td>7.74</td><td>56.87</td><td>25.72</td></tr><tr><td>TTT++ (Ours)</td><td>4.13</td><td>26.20</td><td>21.60</td><td>31.70</td><td>7.43</td><td>83.30</td><td>7.83</td><td>21.10</td><td>7.03</td><td>7.73</td><td>6.91</td><td>51.40</td><td>22.46</td></tr></table>",
+        "bbox": [
+            173,
+            118,
+            825,
+            218
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/b1c9d68fdba7b34f8bbcc722bd3b7570b049750da97f5cdb0f6112a7cb5ecdf8.jpg",
+        "table_caption": [
+            "Table 3: Classification error $( \\% )$ results from online feature alignment with or without a dynamic queue of feature vectors on the CIFAR100-C under level-5 fog corruption. Sample size $=$ Batch size $\\times \\#$ Batches. Given a fixed batch size, enlarging the queue size leads to similar results as having a larger batch size. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">w/o queue</td><td colspan=\"4\">w/ queue</td></tr><tr><td>Sample Size</td><td>64</td><td>128</td><td>256</td><td>64×2</td><td>64×4</td><td>64×8</td><td>64 ×16</td></tr><tr><td>Test Error</td><td>40.31</td><td>38.67</td><td>37.01</td><td>39.84</td><td>37.37</td><td>36.18</td><td>36.02</td></tr></table>",
+        "bbox": [
+            227,
+            286,
+            769,
+            348
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            381,
+            825,
+            465
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.5 Effect of Batch-Queue Decoupling ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            489,
+            449,
+            505
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To verify the effects of batch-queue decoupling, we compare the results of online feature alignment with different sample sizes. Table 3 summarizes the test errors on CIFAR100 under the level-5 fog corruption. As expected, larger sample sizes generally lead to lower classification errors. Interestingly, while the performance of using a dynamic queue is slightly worse than its counterpart of the same sample size from a single large batch, enlarging the queue size always yields stronger results. For instance, given a small batch size of 64, using a dynamic queue maintaining 512 or 1024 feature vectors from 8 or 16 consecutive batches respectively is more advantageous than the vanilla moment matching based on a batch size of 256 samples. This result corroborates the benefit of integrating a dynamic queue into our proposed feature alignment framework, for enhancing the scalability in the online setting. ",
+        "bbox": [
+            173,
+            518,
+            825,
+            657
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.6 Design Choice for Moment Matching ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            681,
+            470,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As discussed in Section 3, our proposed online feature alignment can be instantiated with different orders of moments and applied at various layers. To understand the effects of the detailed design choices, we empirically compare our proposed version against several ablated variants in Table 4. Irrespective of the layer choice, our proposed online feature alignment consistently results in reduced classification error. Nevertheless, moment matching applied to the self-supervised head alone leads to lower test error compared to applying it to the feature extractor output in 11 out of 15 types of corruption. We conjecture that the strong performance of the former one is attributed to the lower dimensionality of the feature vector, which allows for a more accurate estimate of feature statistics. The best result comes from the online feature alignment at the outputs of both the encoder and the projection head, which validates our design choice in Section 3.2. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We further validate the choice of divergence measure through an ablation study. The online feature alignment using the second-order moment (covariance) leads to clearly better results than the one using the first-order moment (mean). It is also evident that the online feature alignment is most effective when both the mean and the covariance are taken into account. ",
+        "bbox": [
+            174,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/c31420b00188b2b1cb239192fdbb2518b3a138842388c3b6235f0d7616739060.jpg",
+        "table_caption": [
+            "Table 4: Classification error $( \\% )$ on CIFAR10-C [1] with different versions of online feature alignment. Taking into account both the first and second-order moments at two different layers is better than the other counterparts in terms of the robustness against most types of image corruptions. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>TFA</td><td>brit</td><td>contr</td><td>defoc</td><td>elast</td><td>fog</td><td>frost</td><td>gauss</td><td>glass</td><td>impul</td><td>jpeg</td><td>motn</td><td>pixel</td><td>shot</td><td>snow</td><td>zoom</td></tr><tr><td>w/oLf.s</td><td>7.96</td><td>7.57</td><td>9.4</td><td>17.24</td><td>14.38</td><td>12.54</td><td>14.62</td><td>21.05</td><td>21.4</td><td>12.68</td><td>11.92</td><td>10.7</td><td>13.7</td><td>12.74</td><td>7.32</td></tr><tr><td>w/oLf,z</td><td>7.85</td><td>7.84</td><td>9.18</td><td>16.51</td><td>14.33</td><td>11.99</td><td>13.79</td><td>20.08</td><td>20.17</td><td>12.42</td><td>12.02</td><td>10.5</td><td>12.78</td><td>13.28</td><td>7.44</td></tr><tr><td>w/£</td><td>7.49</td><td>7.56</td><td>9.62</td><td>18.62</td><td>19.22</td><td>12.72</td><td>16.02</td><td>25.07</td><td>25.17</td><td>13.43</td><td>13.63</td><td>11.22</td><td>15.04</td><td>15.11</td><td>7.77</td></tr><tr><td>w/o μ</td><td>7.43</td><td>7.37</td><td>8.90</td><td>15.92</td><td>12.98</td><td>11.57</td><td>13.46</td><td>19.27</td><td>18.95</td><td>11.87</td><td>11.11</td><td>9.97</td><td>12.81</td><td>11.76</td><td>7.04</td></tr><tr><td>Full</td><td>7.44</td><td>7.40</td><td>8.89</td><td>15.73</td><td>12.82</td><td>11.49</td><td>12.94</td><td>18.46</td><td>19.13</td><td>11.66</td><td>10.77</td><td>9.93</td><td>12.67</td><td>11.73</td><td>7.03</td></tr></table>",
+        "bbox": [
+            173,
+            143,
+            825,
+            224
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion and Discussions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            244,
+            436,
+            262
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we conduct an in-depth analysis of the limitations and potential of self-supervised test-time training. We draw attention to the risk of feature distribution mismatch, which is critical but largely overlooked in recent test-time algorithms. We shed light on the strong potential of this approach by analyzing the growth of test accuracy given improved SSL tasks. These analyses inspire three proposed modifications, namely online feature alignment, batch-queue decoupling and contrastive test-time training, which yield state-of-the-art results on multiple robustness benchmarks. Our results suggest the advantages of bringing additional task-specific and domain-specific information in a compact format for test-time adaptation. We hope these findings will motivate researchers and practitioners to rethink what should be stored, in addition to weight parameters, for the robust deployment of machine learning models. ",
+        "bbox": [
+            174,
+            276,
+            825,
+            416
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Limitations. In this work, we restrain feature summarization to first and second-order moments. Yet, the low-order statistics may be insufficient to characterize the complex distribution of highdimensional features. Developing more advanced summarization methods tailored for test-time adaptation is an interesting avenue for future work. In addition, there may exist a considerable gap between our theoretical analysis and the empirical results, when the stated assumptions do not hold. For instance, neither the classification heads nor the feature alignment is perfect in practice. More theoretical guarantees can be valuable for the practical use of test-time adaptation in safety-critical scenarios. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            544
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Open Questions. In our experiments, we only consider the standard ResNet-50 as the backbone architecture and share the whole feature extractor between the main task and self-supervised task. Yet, recent literature [30, 43] has shown that different layers capture different levels of semantic granularity. The impact of architectural design on test-time training remains an open question. Furthermore, while we empirically compare our proposed method against other families of test-time adaptation algorithms, these techniques exploit different supervisory signals extracted from unlabeled data, which can be complementary to each other. Blending these techniques into a unified framework is another interesting direction to explore in the future. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            672
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Societal Impact. Our work aims at expanding the current horizon of machine learning algorithms for test-time adaptation. For applications where humans’ lives are at risk, such as autonomous driving, trust, safety, robustness are all mandatory keywords. The field has made amazing progress when the training and testing environments are highly similar. What happens when a machine gets deployed in a new environment? We, humans, have an innate capability for handling such shifts. We believe that machines should have the same capability as humans. Indeed, there is a long way to go. Nevertheless, we hope that our work will foster more research in analyzing and devising algorithms for robust and effective adaptation at test time. ",
+        "bbox": [
+            174,
+            690,
+            825,
+            800
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            823,
+            338,
+            839
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was supported by the Swiss National Science Foundation under the Grant 2OOO21- L92326, Honda R&D Co. Ltd, EPFL Open Science fund and Valeo. We thank Sudeep Salgia, Tao Lin, Lingjun Meng, Yifan Sun for helpful inputs to our early drafts and anonymous reviewers for valuable comments. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. Proceedings of the International Conference on Learning Representations, 2019.   \n[2] Mingsheng Long, Yue Cao, Jianmin Wang, and Michael Jordan. Learning Transferable Features with Deep Adaptation Networks. In International Conference on Machine Learning, pages 97–105. PMLR, June 2015. ISSN: 1938-7228.   \n[3] Mingsheng Long, Han Zhu, Jianmin Wang, and Michael I. Jordan. Deep Transfer Learning with Joint Adaptation Networks. In Proceedings of the 34th International Conference on Machine Learning, pages 2208–2217. PMLR, July 2017. ISSN: 2640-3498.   \n[4] Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, François Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. The Journal of Machine Learning Research, 17(1):2096–2030, January 2016.   \n[5] Eric Tzeng, Judy Hoffman, Kate Saenko, and Trevor Darrell. Adversarial Discriminative Domain Adaptation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 7167–7176, 2017.   \n[6] Yu Sun, Xiaolong Wang, Zhuang Liu, John Miller, Alexei Efros, and Moritz Hardt. Test-Time Training with Self-Supervision for Generalization under Distribution Shifts. In Proceedings of the 37th International Conference on Machine Learning, pages 9229–9248. PMLR, November 2020. ISSN: 2640-3498.   \n[7] Jian Liang, Dapeng Hu, and Jiashi Feng. Do we really need to access the source data? source hypothesis transfer for unsupervised domain adaptation. In International Conference on Machine Learning (ICML), pages 6028–6039, July 13–18 2020.   \n[8] Dequan Wang, Evan Shelhamer, Shaoteng Liu, Bruno Olshausen, and Trevor Darrell. Tent: Fully Test-Time Adaptation by Entropy Minimization. In International Conference on Learning Representations, September 2020.   \n[9] Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum Contrast for Unsupervised Visual Representation Learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9729–9738, 2020.   \n[10] Raia Hadsell, Sumit Chopra, and Yann LeCun. Dimensionality Reduction by Learning an Invariant Mapping. In 2006 IEEE Computer Society Conference on Computer Vision and Pattern Recognition - Volume 2 (CVPR’06), volume 2, pages 1735–1742, New York, NY, USA, 2006. IEEE.   \n[11] Zhirong Wu, Yuanjun Xiong, Stella Yu, and Dahua Lin. Unsupervised Feature Learning via Non-parametric Instance Discrimination. In 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 3733–3742, June 2018. ISSN: 2575-7075.   \n[12] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A Simple Framework for Contrastive Learning of Visual Representations. In Proceedings of the 37th International Conference on Machine Learning, pages 1597–1607. PMLR, November 2020. ISSN: 2640- 3498.   \n[13] Assaf Shocher, Nadav Cohen, and Michal Irani. Zero-Shot Super-Resolution Using Deep Internal Learning. In 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 3118–3126, June 2018. ISSN: 2575-7075.   \n[14] Yuejiang Liu, Parth Kothari, and Alexandre Alahi. Collaborative Sampling in Generative Adversarial Networks. Proceedings of the AAAI Conference on Artificial Intelligence, 34(04):4948– 4956, April 2020. Number: 04.   \n[15] David Bau, Hendrik Strobelt, William Peebles, Jonas Wulff, Bolei Zhou, Jun-Yan Zhu, and Antonio Torralba. Semantic photo manipulation with a generative image prior. ACM Transactions on Graphics, 38(4):59:1–59:11, July 2019. ",
+        "bbox": [
+            171,
+            66,
+            828,
+            914
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[16] Jogendra Nath Kundu, Naveen Venkat, Rahul M. V, and R. Venkatesh Babu. Universal SourceFree Domain Adaptation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4544–4553, 2020. ",
+        "bbox": [
+            171,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[17] Steffen Schneider, Evgenia Rusak, Luisa Eck, Oliver Bringmann, Wieland Brendel, and Matthias Bethge. Improving robustness against common corruptions by covariate shift adaptation. Advances in Neural Information Processing Systems, 33, 2020. ",
+        "bbox": [
+            173,
+            142,
+            821,
+            186
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[18] Collin Burns and Jacob Steinhardt. Limitations of Post-Hoc Feature Alignment for Robustness. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 2525–2533, 2021. ",
+        "bbox": [
+            171,
+            195,
+            823,
+            239
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[19] Yang Fu, Sifei Liu, Umar Iqbal, Shalini De Mello, Humphrey Shi, and Jan Kautz. Learning to Track Instances without Video Annotations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8680–8689, 2021. ",
+        "bbox": [
+            171,
+            248,
+            823,
+            291
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[20] Nicklas Hansen, Rishabh Jangir, Yu Sun, Guillem Alenyà, Pieter Abbeel, Alexei A. Efros, Lerrel Pinto, and Xiaolong Wang. Self-Supervised Policy Adaptation during Deployment. In International Conference on Learning Representations, September 2020. ",
+        "bbox": [
+            173,
+            301,
+            825,
+            344
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[21] Arthur Gretton, Karsten M. Borgwardt, Malte J. Rasch, Bernhard Schölkopf, and Alexander Smola. A Kernel Two-Sample Test. Journal of Machine Learning Research, 13(25):723–773, 2012. ",
+        "bbox": [
+            173,
+            353,
+            825,
+            396
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Baochen Sun, Jiashi Feng, and Kate Saenko. Correlation Alignment for Unsupervised Domain Adaptation. In Gabriela Csurka, editor, Domain Adaptation in Computer Vision Applications, Advances in Computer Vision and Pattern Recognition, pages 153–171. Springer International Publishing, Cham, 2017. ",
+        "bbox": [
+            174,
+            406,
+            826,
+            463
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] Werner Zellinger, Thomas Grubinger, Edwin Lughofer, Thomas Natschläger, and Susanne Saminger-Platz. Central Moment Discrepancy (CMD) for Domain-Invariant Representation Learning. International Conference on Learning Representations, International Conference on Learning Representations, November 2016. 00283. ",
+        "bbox": [
+            173,
+            472,
+            825,
+            530
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] Yaroslav Ganin and Victor Lempitsky. Unsupervised Domain Adaptation by Backpropagation. In Proceedings of the 32nd International Conference on Machine Learning, pages 1180–1189. PMLR, June 2015. ISSN: 1938-7228. ",
+        "bbox": [
+            173,
+            539,
+            825,
+            582
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] Mehdi Noroozi and Paolo Favaro. Unsupervised Learning of Visual Representations by Solving Jigsaw Puzzles. In Bastian Leibe, Jiri Matas, Nicu Sebe, and Max Welling, editors, European Conference on Computer Vision, pages 69–84, Cham, 2016. Springer International Publishing. ",
+        "bbox": [
+            171,
+            592,
+            823,
+            636
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Mathilde Caron, Piotr Bojanowski, Armand Joulin, and Matthijs Douze. Deep Clustering for Unsupervised Learning of Visual Features. In Vittorio Ferrari, Martial Hebert, Cristian Sminchisescu, and Yair Weiss, editors, Computer Vision – ECCV 2018, Lecture Notes in Computer Science, pages 139–156, Cham, 2018. Springer International Publishing. ",
+        "bbox": [
+            173,
+            645,
+            826,
+            702
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] Yuejiang Liu, Qi Yan, and Alexandre Alahi. Social NCE: Contrastive Learning of SociallyAware Motion Representations. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 15118–15129, 2021. ",
+        "bbox": [
+            171,
+            710,
+            823,
+            753
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Mathilde Caron, Hugo Touvron, Ishan Misra, Hervé Jégou, Julien Mairal, Piotr Bojanowski, and Armand Joulin. Emerging Properties in Self-Supervised Vision Transformers. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 9650–9660, 2021. ",
+        "bbox": [
+            171,
+            763,
+            825,
+            806
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] Xinlei Chen and Kaiming He. Exploring Simple Siamese Representation Learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 15750–15758, 2021. ",
+        "bbox": [
+            173,
+            815,
+            823,
+            859
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Eric Tzeng, Judy Hoffman, Ning Zhang, Kate Saenko, and Trevor Darrell. Deep Domain Confusion: Maximizing for Domain Invariance. arXiv:1412.3474 [cs], December 2014. arXiv: 1412.3474. ",
+        "bbox": [
+            174,
+            868,
+            826,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Chao Chen, Zhihang Fu, Zhihong Chen, Sheng Jin, Zhaowei Cheng, Xinyu Jin, and Xiansheng Hua. HoMM: Higher-Order Moment Matching for Unsupervised Domain Adaptation. Proceedings of the AAAI Conference on Artificial Intelligence, 34(04):3422–3429, April 2020. Number: 04. ",
+        "bbox": [
+            173,
+            90,
+            828,
+            147
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[32] Amir R. Zamir, Alexander Sax, William Shen, Leonidas J. Guibas, Jitendra Malik, and Silvio Savarese. Taskonomy: Disentangling Task Transfer Learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3712–3722, 2018. ",
+        "bbox": [
+            173,
+            156,
+            823,
+            199
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[33] 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 self-supervised Learning. arXiv:2006.07733 [cs, stat], September 2020. 00623 arXiv: 2006.07733. ",
+        "bbox": [
+            174,
+            207,
+            825,
+            277
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[34] Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised Learning of Visual Features by Contrasting Cluster Assignments. arXiv:2006.09882 [cs], January 2021. 00403 arXiv: 2006.09882. ",
+        "bbox": [
+            171,
+            286,
+            823,
+            329
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[35] Steffen Schneider, Evgenia Rusak, Luisa Eck, Oliver Bringmann, Wieland Brendel, and Matthias Bethge. Removing covariate shift improves robustness against common corruptions. CoRR, abs/2006.16971, 2020. ",
+        "bbox": [
+            173,
+            338,
+            825,
+            380
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[36] Jian Liang, Dapeng Hu, and Jiashi Feng. Do We Really Need to Access the Source Data? Source Hypothesis Transfer for Unsupervised Domain Adaptation. In International Conference on Machine Learning, pages 6028–6039. PMLR, November 2020. ISSN: 2640-3498. ",
+        "bbox": [
+            173,
+            388,
+            823,
+            431
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[37] Pascal Germain, Amaury Habrard, François Laviolette, and Emilie Morvant. A PAC-Bayesian Approach for Domain Adaptation with Specialization to Linear Classifiers. In Proceedings of the 30th International Conference on Machine Learning, pages 738–746. PMLR, May 2013. ISSN: 1938-7228. ",
+        "bbox": [
+            173,
+            440,
+            826,
+            496
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[38] Kaiming He, X. Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 770–778, 2016. ",
+        "bbox": [
+            174,
+            506,
+            826,
+            547
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[39] A. Krizhevsky. Learning multiple layers of features from tiny images, 2009. ",
+        "bbox": [
+            176,
+            556,
+            709,
+            573
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[40] Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do ImageNet Classifiers Generalize to ImageNet? In Proceedings of the 36th International Conference on Machine Learning, pages 5389–5400. PMLR, May 2019. ISSN: 2640-3498. ",
+        "bbox": [
+            174,
+            580,
+            821,
+            623
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[41] Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Francis R. Bach and David M. Blei, editors, Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, volume 37 of JMLR Workshop and Conference Proceedings, pages 448–456. JMLR.org, 2015. ",
+        "bbox": [
+            173,
+            632,
+            826,
+            702
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[42] Xingchao Peng, Ben Usman, Neela Kaushik, Judy Hoffman, Dequan Wang, and Kate Saenko. Visda: The visual domain adaptation challenge. ArXiv, abs/1710.06924, 2017. ",
+        "bbox": [
+            171,
+            710,
+            823,
+            741
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[43] Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How Transferable Are Features in Deep Neural Networks? In Proceedings of the 27th International Conference on Neural Information Processing Systems - Volume 2, NIPS’14, pages 3320–3328, Cambridge, MA, USA, 2014. MIT Press. ",
+        "bbox": [
+            173,
+            748,
+            825,
+            805
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[44] Prannay Khosla, Piotr Teterwak, Chen Wang, Aaron Sarna, Yonglong Tian, Phillip Isola, Aaron Maschinot, Ce Liu, and Dilip Krishnan. Supervised Contrastive Learning. arXiv:2004.11362 [cs, stat], April 2020. arXiv: 2004.11362. ",
+        "bbox": [
+            171,
+            814,
+            823,
+            856
+        ],
+        "page_idx": 12
+    }
+]

parse/train/H1e8wsCqYX/H1e8wsCqYX.md

@@ -0,0 +1,397 @@
+# Laplacian Networks: Bounding Indicator Function Smoothness for Neural Networks Robustness
+
+Anonymous authors Paper under double-blind review
+
+# Abstract
+
+For the past few years, Deep Neural Network (DNN) robustness has become a question of paramount importance. As a matter of fact, in sensitive settings misclassification can lead to dramatic consequences. Such misclassifications are likely to occur when facing adversarial attacks, hardware failures or limitations, and imperfect signal acquisition. To address this question, authors have proposed different approaches aiming at increasing the robustness of DNNs, such as adding regularizers or training using noisy examples. In this paper we propose a new regularizer built upon the Laplacian of similarity graphs obtained from the representation of training data at each layer of the DNN architecture. This regularizer penalizes large changes (across consecutive layers in the architecture) in the distance between examples of different classes, and as such enforces smooth variations of the class boundaries. Since it is agnostic to the type of deformations that are expected when predicting with the DNN, the proposed regularizer can be combined with existing ad-hoc methods. We provide theoretical justification for this regularizer and demonstrate its effectiveness to improve robustness of DNNs on classical supervised learning vision datasets.
+
+# 1 Introduction
+
+Deep Neural Networks (DNNs) provide state-of-the-art performance in many challenges in machine learning (He et al., 2016; Wu et al., 2016). Their ability to achieve good generalization is often explained by the fact they use very few priors about data (LeCun et al., 2015). On the other hand, their strong dependency on data may lead to focus on biased features of the training dataset, resulting in a nonrobust classification performance.
+
+In the literature, authors have been interested in studying the robustness of DNNs in various conditions. These conditions include:
+
+• Robustness to isotropic noise, i.e., small isotropic variations of the input (Mallat, 2016), typically meaning that the network function leads to a small Lipschitz constant.   
+Robustness to adversarial attacks, which can exploit knowledge about the network parameters or the training dataset (Szegedy et al., 2013; Goodfellow et al., 2014).   
+• Robustness to implementation defects, which can result in only approximately correct computations (Hubara et al., 2017).
+
+To improve DNN robustness, three main families of solutions have been proposed in the literature. The first one involves enforcing smoothness, as measured by a Lipschitz constant, in the operators and having a minimum separation margin (Mallat, 2016). A similar approach has been proposed in (Cisse et al., 2017), where the authors restrict the function of the network to be contractive. A second class of methods use intermediate representations obtained at various layers to perform the prediction (Papernot and McDaniel, 2018). Finally, in (Kurakin et al., 2016; Pezeshki et al., 2016; Madry et al., 2018), the authors propose to train the network using noisy inputs so that it better generalizes to this type of noise. This has been shown to improve the robustness of the network to the specific type of noise used during training, but it is not guaranteed that this robustness would be extended to other types of deformations.
+
+In this work, we introduce a new regularizer that does not focus on a specific type of deformation, but aims at increasing robustness in general. As such, the proposed regularizer can be combined with other existing methods. It is inspired by recent developments in Graph Signal Processing (GSP) (Shuman et al., 2013). GSP is a mathematical framework that extends classical Fourier analysis to complex topologies described by graphs, by introducing notions of frequency for signals defined on graphs. Thus, signals that are smooth on the graph (i.e., change slowly from one node to its neighbors) will have most of their energy concentrated in the low frequencies.
+
+The proposed regularizer is based on constructing a series of graphs, one for each layer of the DNN architecture, where each graph captures the similarity between all training examples given their intermediate representation at that layer. Our proposed regularizer penalizes large changes in the smoothness of class indicator vectors (viewed here as graph signals) from one layer to the next. As a consequence, the distances between pairs of examples in different classes are only allowed to change slowly from one layer to the next. Note that because we use deep architectures, the regularizer does not prevent the smoothness from achieving its maximum value, but constraining the size of changes from layer to layer increases the robustness of the network function by controlling the distance to the boundary region, as supported by experiments in Section 4.
+
+The outline of the paper is as follows. In Section 2 we present related work. In Section 3 we introduce the proposed regularizer. In Section 4 we evaluate the performance of our proposed method in various conditions and on vision benchmarks. Section 5 summarizes our conclusions.
+
+# 2 Related work
+
+DNN robustness may refer to many different problems. In this work we are mostly interested in the stability to deformations (Mallat, 2016), or noise, which can be due to multiple factors mentioned in the introduction. The most studied stability to deformations is in the context of adversarial attacks. It has been shown that very small imperceptible changes on the input of a trained DNN can result in missclassification of the input (Szegedy et al., 2013; Goodfellow et al., 2014). These works have been primordial to show that DNNs may not be as robust to deformations as the test accuracy benchmarks would have lead one to believe. Other works, such as (Recht et al., 2018), have shown that DNNs may also suffer from drops in performance when facing deformations that are not originated from adversarial attacks, but simply by re-sampling the test images.
+
+Multiple ways to improve robustness have been proposed in the literature. They range from the use of a model ensemble composed of $k$ -nearest neighbors classifiers for each layer (Papernot and McDaniel, 2018), to the use of distillation as a mean to protect the network (Papernot et al., 2016a). Other methods introduce regularizers (Gu and Rigazio, 2014), control the Lipschitz constant of the network function (Cisse et al., 2017) or implement multiple strategies revolving around using deformations as a data augmentation procedure during the training phase (Goodfellow et al., 2014; Kurakin et al., 2016; Moosavi Dezfooli et al., 2016).
+
+Compared to these works, our proposed method can be viewed as a regularizer that penalizes large deformations of the class boundaries throughout the network architecture, instead of focusing on a specific deformation of the input. As such, it can be combined with other mentioned strategies. Indeed, we demonstrate that the proposed method can be implemented in combination with (Cisse et al., 2017), resulting in a network function such that small variations to the input lead to small variations in the decision, as in (Cisse et al., 2017), while limiting the amount of change to the class boundaries. Note that our approach does not require using training data affected by a specific deformation, and our results could be further improved if such data were available for training, as shown in the Appendix.
+
+As for combining GSP and machine learning, this area has sparked interest recently. For example, the authors of (Gripon et al., 2018) show that it is possible to detect overfitting by tracking the evolution of the smoothness of a graph containing only training set examples. Another example is in (Anirudh et al., 2017) where the authors introduce different quantities related to GSP that can be used to extract interpretable results from DNNs. In (Svoboda et al., 2018) the authors exploit graph convolutional layers (Bronstein et al., 2017) to increase the robustness of the network.
+
+To the best of our knowledge, this is the first use of graph signal smoothness as a regularizer for deep neural network design.
+
+# 3 Methodology
+
+# 3.1 Similarity preset and postset graphs
+
+Consider a deep neural network architecture. Such a network is obtained by assembling layers of various types. Of particular interest are layers of the form $\mathbf { x } ^ { \ell } \mapsto \mathbf { x } ^ { \ell + 1 } = h ^ { \ell } ( \mathbf { W } ^ { \ell } \mathbf { x } ^ { \ell } + \mathbf { b } ^ { \ell } )$ , where $h ^ { \ell }$ is a nonlinear function, typically a ReLU, $\mathbf { W } ^ { \ell }$ is the weight tensor at layer $\ell$ , $\mathbf { x } ^ { \ell }$ is the intermediate representation of the input at layer $\ell$ and $\mathbf { b } ^ { \ell }$ is the corresponding bias tensor. Note that strides or pooling may be used. Assembling can be achieved in various ways: composition, concatenation, sums. . . so that we obtain a global function $f$ that associates an input tensor $\mathbf { x } ^ { 0 }$ to an output tensor $\mathbf { y } = f ( \mathbf { x } ^ { 0 } )$ .
+
+When computing the output $\mathbf { y }$ associated with the input $\mathbf { x } ^ { 0 }$ , each layer $\ell$ of the architecture processes some input $\mathbf { x } ^ { \ell }$ and computes the corresponding output $\mathbf { y } ^ { \ell } = h ^ { \ell } ( \mathbf { W } ^ { \ell } \mathbf { x } ^ { \ell } + \mathbf { b } ^ { \ell } )$ For a given layer $\ell$ and a batch of $b$ inputs $\mathcal { X } = \{ \mathbf { x } _ { 1 } , \ldots , \mathbf { x } _ { b } \}$ , we can obtain two sets $\mathcal { X } ^ { \ell } = \{ \mathbf { x } _ { 1 } ^ { \ell } , \ldots , \mathbf { x } _ { b } ^ { \ell } \}$ , called the preset, and $\mathcal { V } ^ { \ell } = \{ \mathbf { y } _ { 1 } ^ { \ell } , \ldots , \mathbf { y } _ { b } ^ { \ell } \}$ , called the postset.
+
+Given a similarity measure $s$ on tensors, from a preset we can build the similarity preset matrix: $\mathbf { M } _ { p r e } ^ { \ell } [ i , j ] = s ( \mathbf { x } _ { i } ^ { \ell } , \mathbf { x } _ { j } ^ { \ell } ) , \forall 1 \le i , j \le b$ , where $\mathbf { M } [ i , j ]$ denotes the element at line $i$ and column $j$ in $\mathbf { M }$ . The postset matrix is defined similarly.
+
+Consider a similarity (either preset or postset) matrix $\mathbf { M } ^ { \ell }$ . This matrix can be used to build a $k$ -nearest neighbor similarity weighted graph $G ^ { \ell } = \langle V , \mathbf { A } ^ { \ell } \rangle$ , where $V = \{ 1 , \ldots , b \}$ is the set of vertices and $\mathbf { A } ^ { \ell }$ is the weighted adjacency matrix defined as:
+
+$$
+\begin{array} { r } { \mathbf { A } ^ { \ell } [ i , j ] = \left\{ \begin{array} { l l } { \mathbf { M } ^ { \ell } [ i , j ] } & { \mathrm { i f } \ \mathbf { M } ^ { \ell } [ i , j ] \in \mathrm { a r g } \operatorname* { m a x } _ { i ^ { \prime } \neq j } \big ( \mathbf { M } ^ { \ell } [ i ^ { \prime } , j ] , k \big ) } \\ & { \big \downarrow \mathrm { a r g } \operatorname* { m a x } _ { j ^ { \prime } \neq i } \big ( \mathbf { M } ^ { \ell } [ i , j ^ { \prime } ] , k \big ) } \\ { 0 } & { \mathrm { o t h e r w i s e } } \end{array} \right. , \forall i , j \in V , } \end{array}
+$$
+
+where arg $\operatorname* { m a x } _ { i } ( a _ { i } , k )$ denotes the indices of the $k$ largest elements in $\{ a _ { 1 } , \ldots , a _ { b } \}$ . Note that by construction $\mathbf { A } ^ { \ell }$ is symmetric.
+
+# 3.2 Smoothness of label signals
+
+Given a weighted graph $G ^ { \ell } = \langle V , \mathbf { A } ^ { \ell } \rangle$ , we call Laplacian of $G ^ { \ell }$ the matrix $\mathbf { L } ^ { \ell } = \mathbf { D } ^ { \ell } - \mathbf { A } ^ { \ell }$ , where $\mathbf { D } ^ { \ell }$ is the diagonal matrix such that: $\begin{array} { r } { \mathbf { D } ^ { \ell } [ i , i ] = \sum _ { j } \mathbf { A } ^ { \ell } [ i , j ] , \forall i \in V } \end{array}$ . Because $\mathbf { L } ^ { \ell }$ is symmetric and real-valued, it can be written:
+
+$$
+\mathbf { L } ^ { \ell } = \mathbf { F } ^ { \ell } \mathbf { A } ^ { \ell } \mathbf { F } ^ { \ell \top } ,
+$$
+
+where $\mathbf { F }$ is orthonormal and contains eigenvectors of $\mathbf { L } ^ { \ell }$ as columns, $\mathbf { F } ^ { \top }$ denotes the transpose of $\mathbf { F }$ , and $\pmb { \Lambda }$ is diagonal and contains eigenvalues of $\mathbf { L } ^ { \ell }$ is ascending order. Note that the constant vector $\mathbf { 1 } \in \mathbb { R } ^ { b }$ is an eigenvector of $\mathbf { L } ^ { \ell }$ corresponding to eigenvalue 0. Moreover, all√ eigenvalues of $\mathbf { L } ^ { \ell }$ are nonnegative. Consequently, $\mathbf { 1 } / \sqrt { n }$ can be chosen as the first column in $\mathbf { F }$ .
+
+Consider a vector $\mathbf { s } \in \mathbb { R } ^ { b }$ , we define $\hat { \bf S }$ the Graph Fourier Transform (GFT) of s on $G ^ { \ell }$ as (Shuman et al., 2013):
+
+$$
+\hat { \mathbf { s } } = \mathbf { F } ^ { \top } \mathbf { s } .
+$$
+
+Because the order of the eigenvectors is chosen so that the corresponding eigenvalues are in ascending order, if only the first few entries of $\hat { \bf s }$ are nonzero that indicates that s is low frequency (smooth). In the extreme case where only the first entry of $\hat { \bf s }$ is nonzero we have that $\mathbf { s }$ is constant (maximum smoothness). More generally, smoothness $\sigma ^ { \ell } ( \mathbf { s } )$ of a signal s can be measured using the quadratic form of the Laplacian:
+
+$$
+\sigma ^ { \ell } ( \mathbf { s } ) = \mathbf { s } ^ { \top } \mathbf { L } ^ { \ell } \mathbf { s } = \sum _ { i , j = 1 } ^ { b } \mathbf { A } ^ { \ell } [ i , j ] ( \mathbf { s } [ i ] - \mathbf { s } [ j ] ) ^ { 2 } = \sum _ { i = 1 } ^ { b } \mathbf { A } ^ { \ell } [ i , i ] \hat { \mathbf { s } } [ i ] ^ { 2 } ,
+$$
+
+where we note that $\mathbf { s }$ is smoother when $\sigma ^ { \ell } ( \mathbf { s } )$ is smaller.
+
+In this paper we are particularly interested in smoothness of the label signals. We call label signal $\mathbf { s } _ { c }$ associated with class $c$ a binary $( \{ 0 , 1 \} )$ vector whose nonzero coordinates are the ones corresponding to input vectors of class $c$ . In other words, $\mathbf { s } _ { c } [ i ] = 1 \Leftrightarrow ( \mathbf { x } _ { i }$ is in class $c ) , \forall 1 \leq i \leq b$ . Using Equation (4), we obtain that the smoothness of the label signal $\mathbf { s } _ { c }$ is the sum of similarities between examples in distinct classes. Thus a smoothness of 0 means that examples in distinct classes have 0 similarity.
+
+Denote $u$ the last layer of the architecture: $\mathbf { y } _ { i } ^ { u } = \mathbf { y } _ { i } , \forall i$ . Note that in typical settings, where outputs of the networks are one-hot-bit encoded and no regularizer is used, at the end of the learning process it is expected that $\mathbf { y } _ { i } ^ { \top } \mathbf { y } _ { j } \approx 1$ if $i$ and $j$ belong to the same class, and $\mathbf { y } _ { i } ^ { \top } \mathbf { y } _ { j } \approx 0$ otherwise.
+
+Thus, assuming that cosine similarity is used to build the graph, the last layer smoothness for all $c$ would be $\sigma _ { p o s t } ^ { u } ( \mathbf { s } _ { c } ) \approx 0$ , since edge weights between nodes having different labels will be close to zero given Equation (4). More generally, smoothness of ${ \bf s } _ { c }$ at the preset or postset of a given layer measures the average similarity between examples in class $c$ and examples in other classes ( $\sigma ( \mathbf { s } _ { c } )$ decreases as the weights of edges connecting nodes in different classes decrease). Because the last layer can achieve $\sigma ( \mathbf { s } _ { c } ) \approx 0$ , we expect the smoothness metric $\sigma$ at each layer to decrease as we go deeper in the network. Next we introduce a regularization strategy that limits how much $\sigma$ can decrease from one layer to the next and can even prevent the last layer from achieving $\sigma ( \mathbf { s } _ { c } ) = 0$ . This will be shown to improve generalization and robustness. The theoretical motivation for this choice is discussed in Section 3.4.
+
+# 3.3 Proposed regularizer
+
+# 3.3.1 Definition
+
+We propose to measure the deformation induced by a given layer $\ell$ in the relative positions of examples by computing the difference between label signal smoothness before and after the layer, averaged over all labels:
+
+$$
+\delta _ { \sigma } ^ { \ell } = \left| \sum _ { c } \left[ \sigma _ { p o s t } ^ { \ell } ( \mathbf { s } _ { c } ) - \sigma _ { p r e } ^ { \ell } ( \mathbf { s } _ { c } ) \right] \right| .
+$$
+
+These quantities are used to regularize modifications made to each of the layers during the learning process.
+
+Remark 1: Since we only consider label signals, we solely depend on the similarities between examples that belong to distinct classes. In other words, the regularizer only focuses on the boundary region, and does not vary if the distance between examples of the same label grows or shrinks. This is because forcing similarities between examples of a same class to evolve slowly could prevent the network to train appropriately.
+
+Remark 2: Compared with (Cisse et al., 2017), there are three key differences that characterize the proposed regularizer:
+
+1. Not all pairwise distances are taken into account in the regularization; only distances between examples corresponding to different classes play a role in the regularization. 2. We allow a limited amount of both contraction and dilation of the metric space. Experimental work (e.g. (Gripon et al., 2018; Papernot and McDaniel, 2018)) has shown that the evolution of metric spaces across DNN layers is complex, and thus restricting ourselves to contractions only could lead to lower overall performance.
+
+![](images/7a25bf2a8ce82d3d28ee143d3c0bd7c181607d6ab447cfb5742dc258feb54e06.jpg)  
+Figure 1: Illustration of the effect of our proposed regularizer. In this example, the goal is to classify circles and crosses (top). Without use of regularizers (bottom left), the resulting embedding may considerably stretch the boundary regions (as illustrated by the irregular spacing between the tics). Forcing small variations of smoothness of label signals (bottom right), we ensure the topology is not dramatically changed in the boundary regions.
+
+3. The proposed criterion is an average (sum) over all distances, rather than a stricter criterion (e.g. Lipschitz), which would force each pair of vectors $\left( \mathbf { x } _ { i } , \mathbf { x } _ { j } \right)$ to obey the constraint.
+
+# Illustrative example:
+
+In Figure 1 we depict a toy illustrative example to motivate the proposed regularizer. We consider here a one-dimensional two-class problem. To linearly separate circles and crosses, it is necessary to group all circles. Without regularization (setting i)), the resulting embedding is likely to increase considerably the distance between examples and the size of the boundary region between classes. In contrast, by penalizing large variations of the smoothness of label signals (setting ii)), the average distance between circles and crosses must be preserved in the embedding domain, resulting in a more precise control of distances within the boundary region.
+
+# 3.4 Motivation: label signal bandwidth and powers of the Laplacian
+
+Recent work (Anis et al., 2017) develops an asymptotic analysis of the bandwidth of label signals, $B W ( \mathbf { s } )$ , where bandwidth is defined as the highest non-zero graph frequency of $\mathbf { s }$ , i.e., the nonzero entry of $\hat { \bf S }$ with the highest index. An estimate of the bandwidth can be obtained by computing:
+
+$$
+B W _ { m } ( \mathbf { s } ) = \left( \frac { \mathbf { s } ^ { \top } \mathbf { L } ^ { m } \mathbf { s } } { \mathbf { s } ^ { \top } \mathbf { s } } \right) ^ { ( 1 / m ) }
+$$
+
+for large $m$ . This can be viewed as a generalization of the smoothness metric of (4). (Anis et al., 2017) shows that, as the number of labeled points $\mathbf { x }$ (assumed drawn from a distribution $p ( \mathbf { x } )$ ) grows asymptotically, the bandwidth of the label signal converges in probability to the supremum of $p ( \mathbf { x } )$ in the region of overlap between classes. This motivates our work in three ways.
+
+First, it provides theoretical justification to use $\sigma ^ { \ell } ( \mathbf { s } )$ for regularization, since lower values of $\sigma ^ { \ell } ( \mathbf { s } )$ are indicative of better separation between classes. Second, the asymptotic analysis suggests that using higher powers of the Laplacian would lead to better regularization, since estimating bandwidth using $B W _ { m } ( \mathbf { s } )$ becomes increasingly accurate as $m$ increases. Finally, this regularization can be seen to be protective against specializing by preventing $\sigma ^ { \ell } ( \mathbf { s } )$
+
+![](images/73d63bbea2a418473334189f58913372f40d6a939f0e5899c465fb9fd05d7e53.jpg)  
+Figure 2: Sample of a Laplacian and squared Laplacian of similarity graphs in a trained vanilla architecture. Examples of the batch have been ordered so that those belonging to a same class are consecutive. Dark values correspond to high similarity.
+
+![](images/173363ce406f53c38ec33eda09d6e9615ac6193eca26568f2545fec2b5ff4e33.jpg)  
+Figure 3: Evolution of smoothness of label signals as a function of layer depth, and for various regularizers and choice of $m$ , the power of the Laplacian matrix.
+
+from decreasing “too fast”. For most problems of interest, given a sufficiently large amount of labeled data available, it would be reasonable to expect the bandwidth of s not to be arbitrarily small, because the classes cannot be exactly separated, and thus a network that reduces the bandwidth too much can result in being biased by the training set.
+
+# 3.5 Analysis of the Laplacian powers
+
+In Figure 2 we depict the Laplacian and squared Laplacian of similarity graphs obtained at different layers in a trained vanilla architecture. On the deep layers, we can clearly see blocks corresponding to the classes, while the situation in the middle layer is not as clear. This figure illustrates how using the squared Laplacian helps modifying the distances to improve separation. Note that we normalize the squared Laplacian values by dividing them by the highest absolute value.
+
+In Figure 3, we plot the average evolution of smoothness of label signals over 100 batches, as a function of layer depth in the architecture, and for different choices of the regularizer. In the left part, we look at smoothness measures using the Laplacian. In the right part, we use the squared Laplacian. We can clearly see the effectiveness of the regularizer in enforcing small variations of smoothness across the architecture. Note that for model regularized with $\mathbf { L } ^ { 2 }$ , changes in smoothness measured by $\mathbf { L }$ are not easy to see. This seems to suggest that some of the gains achieved via $\mathbf { L } ^ { 2 }$ regularization come in making changes that would be “invisible” when looking at the layers from the perspective of $\mathbf { L }$ smoothness. The same normalization from Figure 2 is used for $\mathbf { L } ^ { 2 }$ .
+
+# 4 Experiments
+
+In the following paragraphs we evaluate the proposed method using various tests. We use the well known CIFAR-10 (Krizhevsky and Hinton, 2009) dataset made of tiny images. As far as the DNN is concerned, we use the same PreActResNet (He et al., 2016) architecture for all tests, with 18 layers. All inputs, including those on the test set, are normalized based on the mean and standard deviation of the images of the training set. In all figures, P are
+
+![](images/0725dbe5fecdc238b7a4583c2aa38693c67f9dc4d939d619fa6ea0eccd7e0de4.jpg)  
+Figure 4: Test set accuracy under Gaussian noise with varying signal-to-noise ratio.
+
+Parseval trained networks, R are networks trained with the proposed regularizer and V are vanilla networks. More details and experiments can be found at the Appendix.
+
+We depict the obtained results using box plots where data is aggregated from 10 different networks corresponding to different random seeds and batch orders. In the first experiment (left most plot) in Figure 4, we plot the baseline accuracy of the models on the clean test set (no deformation is added at this point). These experiments agree with the claim from (Cisse et al., 2017) where the authors show that they are able to increase the performance of the network on the clean test set. We observe that our proposed method leads to a minor decrease of performance on this test. However, we see in the following experiments that this is mitigated with increased robustness to deformations. Such a trade-off between robustness and accuracy has already been discussed in the literature (Fawzi et al., 2018).
+
+# 4.1 Isotropic deformation
+
+In this scenario we evaluate the robustness of the network function to small isotropic variations of the input. We generate 40 different deformations using random variables $\mathcal { N } ( 0 , 0 . 2 5 )$ which are added to the test set inputs. Note that they are scaled so that $S N R \approx 1 5$ and $S N R \approx 2 0$ . The middle and right-most plots from Figure 4 show that the proposed method increases the robustness of the network to isotropic deformations. Note that in both scenarios the best results are achieved by combining Parseval training and our proposed method (lower-most box on both figures).
+
+# 4.2 Adversarial Robustness
+
+We next evaluate robustness to adversarial inputs, which are specifically built to fool the network function. Such adversarial inputs can be generated and evaluated in multiple ways. Here we implement two approaches: first a mean case of adversarial noise, where the adversary can only use one forward and one backward pass to generate the deformations, and second a worst case scenario, where the adversary can use multiple forward and backward passes to try to find the smallest deformation that will fool the network.
+
+For the first approach, we add the scaled gradient sign (FGSM attack) on the input (Kurakin et al., 2016), so that we obtain a target $S N R = 3 3$ . Results are depicted in the left and center plots of Figure 5. In the left plot the noise is added after normalizing the input whereas on the middle plot it is added before normalizing. As in the isotropic noise case, a combination of the Parseval method and our proposed approach achieves maximum robustness.
+
+In regards to the second approach, where a worst case scenario is considered, we use the Foolbox toolbox (Rauber et al., 2017) implementation of DeepFool (Moosavi Dezfooli et al., 2016). Due to time constraints we sample only conclusions are similar (right plot of Figure 5) $\frac { 1 } { 1 0 }$ of the test set images for this test. The those obtained for the first adversarial attack approach.
+
+# 4.3 Implementation robustness
+
+Finally, in a third series of experiments we evaluate the robustness of the network functions to faulty implementations. As a result, approximate computations are made during the test phase that consist of random erasures of the memory (dropout) or quantization of the weights (Hubara et al., 2017).
+
+![](images/2ab1322d49785d870ab7882360f5ae11d0d07ec25f14d216ba1dac2a2ebd9f2f.jpg)  
+Figure 5: Robustness against an adversary measured by the test set accuracy under FGSM attack in the left and center plots and by the mean $\mathcal { L } _ { 2 }$ pixel distance needed to fool the network using DeepFool on the right plot.
+
+![](images/a8936bbbb51a644d3db02833cb32295ca058a56194f76a35ad3ee4febde65478.jpg)  
+Figure 6: Test set accuracy under different types of implementation related noise.
+
+In the dropout case, we compute the test set accuracy when the network has a probability of either $2 5 \%$ or $4 0 \%$ of dropping a neuron’s value after each block. We run each experiment 40 times. The results are depicted in the left and center plots of Figure 6. It is interesting to note that the Parseval trained functions seem to drop in performance as soon as we reach $4 0 \%$ probability of dropout, providing an average accuracy smaller than the vanilla networks. In contrast, the proposed method is the most robust to these perturbations.
+
+For the quantization of the weights, we consider a scenario where the network size in memory has to be shrink 6 times. We therefore quantize the weights of the networks to 5 bits (instead of 32) and re-evaluate the test set accuracy. The right plot of Figure 6 shows that the proposed method is providing a better robustness to this kind of deformation than the tested counterparts.
+
+# 5 Conclusion
+
+In this paper we have introduced a new regularizer that enforces small variations of the smoothness of label signals on similarity graphs obtained at intermediate layers of a deep neural network architecture. We have empirically shown with our tests that it can lead to improved robustness in various conditions compared to existing counterparts. We also demonstrated that combining the proposed regularizer with existing methods can result in even better robustness for some conditions.
+
+Future work includes a more systematic study of the effectiveness of the method with regards to other datasets, models and deformations. Recent works shown adversarial noise is partially transferable between models and dataset (Moosavi-Dezfooli et al., 2017; Papernot et al., 2016b) and therefore we are confident about the generality of the method in terms of models and datasets.
+
+One possible extension of the proposed method is to use it in a fine-tuning stage, combined with different techniques already established on the literature. An extension using a combination of input barycenter and class barycenter signals instead of the class signal could be interesting as that would be comparable to (Zhang et al., 2017). In the same vein, using random signals could be beneficial for semi-supervised or unsupervised learning challenges.
+
+# References
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European Conference on Computer Vision, pages 630–645. Springer, 2016.
+
+Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016.
+
+Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. nature, 521(7553):436, 2015.
+
+Stéphane Mallat. Understanding deep convolutional networks. Phil. Trans. R. Soc. A, 374 (2065):20150203, 2016.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Quantized neural networks: Training neural networks with low precision weights and activations. Journal of Machine Learning Research, 18:187–1, 2017.
+
+Moustapha Cisse, Piotr Bojanowski, Edouard Grave, Yann Dauphin, and Nicolas Usunier. Parseval networks: Improving robustness to adversarial examples. In International Conference on Machine Learning, pages 854–863, 2017.
+
+Nicolas Papernot and Patrick D. McDaniel. Deep k-nearest neighbors: Towards confident, interpretable and robust deep learning. CoRR, abs/1803.04765, 2018. URL http://arxiv. org/abs/1803.04765.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016.
+
+Mohammad Pezeshki, Linxi Fan, Philemon Brakel, Aaron Courville, and Yoshua Bengio. Deconstructing the ladder network architecture. In International Conference on Machine Learning, pages 2368–2376, 2016.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum? id=rJzIBfZAb.
+
+David I Shuman, Sunil K Narang, Pascal Frossard, Antonio Ortega, and Pierre Vandergheynst. The emerging field of signal processing on graphs: Extending high-dimensional data analysis to networks and other irregular domains. IEEE Signal Processing Magazine, 30(3):83–98, 2013.
+
+Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do cifar-10 classifiers generalize to cifar-10? arXiv preprint arXiv:1806.00451, 2018.
+
+Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In Security and Privacy (SP), 2016 IEEE Symposium on, pages 582–597. IEEE, 2016a.
+
+Shixiang Gu and Luca Rigazio. Towards deep neural network architectures robust to adversarial examples. arXiv preprint arXiv:1412.5068, 2014.
+
+Seyed Mohsen Moosavi Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
+
+Vincent Gripon, Antonio Ortega, and Benjamin Girault. An inside look at deep neural networks using graph signal processing. In Proceedings of ITA, February 2018.
+
+Rushil Anirudh, Jayaraman J Thiagarajan, Rahul Sridhar, and Timo Bremer. Influential sample selection: A graph signal processing approach. arXiv preprint arXiv:1711.05407, 2017.
+
+Jan Svoboda, Jonathan Masci, Federico Monti, Michael M Bronstein, and Leonidas Guibas. Peernets: Exploiting peer wisdom against adversarial attacks. arXiv preprint arXiv:1806.00088, 2018.
+
+Michael M Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. IEEE Signal Processing Magazine, 34(4):18–42, 2017.
+
+Aamir Anis, Aly El Gamal, Salman Avestimehr, and Antonio Ortega. A sampling theory perspective of graph-based semi-supervised learning. arXiv preprint arXiv:1705.09518, 2017.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. https://www.cs.toronto.edu/ kriz/learning-features-2009-TR.pdf, 2009.
+
+Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Analysis of classifiers’ robustness to adversarial perturbations. Machine Learning, 107(3):481–508, 2018.
+
+Jonas Rauber, Wieland Brendel, and Matthias Bethge. Foolbox: A python toolbox to benchmark the robustness of machine learning models. arXiv preprint arXiv:1707.04131, 2017. URL http://arxiv.org/abs/1707.04131.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Universal adversarial perturbations. arXiv preprint, 2017.
+
+Nicolas Papernot, Patrick McDaniel, and Ian Goodfellow. Transferability in machine learning: from phenomena to black-box attacks using adversarial samples. arXiv preprint arXiv:1605.07277, 2016b.
+
+Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017.
+
+Jelena Kovačević and Amina Chebira. An introduction to frames. Foundations and Trends in Signal Processing, 2(1):1–94, 2008.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks, 2016.
+
+# A Parseval Training and implementation
+
+We compare our results with those obtained using the method described in (Cisse et al., 2017). There are three modifications to the normal training procedure: orthogonality constraint, convolutional renormalization and convexity constraint.
+
+For the orthogonality constraint we enforce Parseval tightness (Kovačević and Chebira, 2008) as a layer-wise regularizer:
+
+$$
+R _ { \beta } ( W ^ { \ell } ) = \frac { \beta } { 2 } \| W ^ { \ell ^ { \top } } W ^ { \ell } - I \| _ { 2 } ^ { 2 } ,
+$$
+
+where $W _ { \ell }$ is the weight tensor at layer $\ell$ . This function can be approximately optimized with gradient descent by doing the operation:
+
+$$
+\begin{array} { r } { W ^ { \ell } \gets ( 1 + \beta ) W ^ { \ell } - \beta W ^ { \ell } W ^ { \ell \top } W ^ { \ell } . } \end{array}
+$$
+
+Given that our network is smaller we can apply the optimization to the entirety of the $W$ , instead of $3 0 \%$ as per the original paper, this increases the strength of the Parseval tightness.
+
+For the convolutional renormalization, each matrix $W ^ { \ell }$ is reparametrized before being applied to the convolution as $\frac { W ^ { \ell } } { \sqrt { 2 k _ { s } + 1 } }$ , where $k _ { s }$ is the kernel size.
+
+For our architecture the inputs from a layer come from either one or two different layers. In the case where the inputs come from only one layer, $\alpha$ the convexity constraint parameter is set to 1. When the inputs come from the sum of two layers we use $\alpha = 0 . 5$ as the value for both of them, which constraints our Lipschitz constant, this is softer than the convexity constraint from the original paper.
+
+# B Hyperparameters
+
+We train our networks using classical stochastic gradient descent with momentum (0.9), with batch size of $b = 1 0 0$ images and using a L2-norm weight decay with a coefficient of $\lambda = 0 . 0 0 0 5$ . We do a 100 epoch training. Our learning rate starts at 0.1. After half of the training (50 epochs) the learning rate decreases to 0.001.
+
+We use the mean of the difference of smoothness between successive layers in our loss function. Therefore in our loss function we have:
+
+$$
+\mathcal { L } = C a t e g o r i c a l C r o s s E n t r o p y + \lambda W e i g h t D e c a y + \gamma \Delta
+$$
+
+where $\begin{array} { r } { \Delta = \frac { 1 } { d - 1 } \sum _ { \ell = 1 } ^ { d } | \delta _ { \sigma } ^ { \ell } | } \end{array}$ . We perform experiments using various powers of the Laplacian $m = 1 , 2 , 3$ , in which case the scaling coefficient $\gamma$ is put to the same power as the Laplacian.
+
+We tested multiple parameters of $\beta$ , the Parseval tightness parameter, $\gamma$ the weight for the smoothness difference cost and $m$ the power of the Laplacian. We found that the best values for this specific architecture, dataset and training scheme were: $\beta = 0 . 0 1 , \gamma = 0 . 0 1 , m =$ $2 , k = b$ .
+
+# C Depiction of the network
+
+Figure 7 depicts the network used on all experiments of sections 3 and 4. $f = 6 4$ is the filter size of the first layer of the network. Conv layers are 3x3 layers and are always preceded by batch normalization and relu (except for the first layer which receives just the input). The smoothness gaps are calculated after each ReLU.
+
+![](images/07d6ffb8eb74f6adedb2e817c6a62fc1def128093e82756536554b38c46cfae1.jpg)  
+Figure 7: Depiction of the studied network
+
+# D Additional experiments
+
+Given suggestions from the reviewers, we performed additional experiments to further demonstrate the capabilities of the proposed regularizer. Due to the lack of space they could not be added to the main paper. We consider the effects of the regularizer when applied on another datasets. We also consider the effects of adding adversarial data augmentation methods while minimizing the amount of other influencing factors. We first look at the results when using the same architecture as for the CIFAR-10 dataset, which inevitably results in far from state-of-the-art accuracy on CIFAR-100. Then, we perform experiments using a different architecture (namely WideResnet 28-10, with dropout) for CIFAR-100.
+
+# D.1 CIFAR-10
+
+We add two types of tests for the CIFAR-10 dataset: adversarial data augmentation during training and black-box FGSM.
+
+# D.1.1 Tests with FGSM adversarial data augmentation
+
+In this section we consider tests adding adversarial data augmentation as suggested in (Kurakin et al., 2016). To be more precise we use the method they advise which is called "step1.1" using $\begin{array} { r } { \epsilon = \frac { 8 } { 2 5 5 } } \end{array}$ . The results presented in the figures below are obtained by running 10 experiments with random initializations. We first perform the same tests as in Section 4.
+
+As expected, we observe in Figure 8 that training with adversarial examples help in the case of Gaussian noise, as it adds more variation to the training set, while reducing the accuracy on the clean set. Note that combining our method with adversarial training results in the best median accuracy. Combining the three methods is less successful than expected, which could indicate that a better hyperparameter search would be needed.
+
+![](images/fae2ea7c754238bce049a2b05c63a32bfcce3522e9fb94af1c4b1e8a28f137a1.jpg)  
+Figure 8: Test set accuracy under Gaussian noise with varying Signal-to-Noise Ratio (SNR). A is for Adversarial, $\mathrm { P }$ is for Parseval, R is for the proposed Regularizer and V is for Vanilla network.
+
+Considering adversarial robustness, the obtained results are depicted in Figure 9. We observe that adding FGSM adversarial training does not generalize well to other types of attack (which is readily seen in the literature Madry et al. (2018)). Overall, the models using the proposed regularizer are the most robust.
+
+Finally, when considering implementation related perturbations, the results depicted in Figure 10 are consistent with the ones from Section 4.3, in which is shown that the proposed regularizer helps improving robustness.
+
+In summary, even when adding adversarial training, the proposed regularizer is either the most robust in median, or capable of improving the robustness when used combined with the other methods.
+
+![](images/71910dcdc84c86529e0d19400ca2e215f1ed1915780cfeefb93df7906671f83c.jpg)  
+Figure 9: Robustness against an adversary measured by the test set accuracy under FGSM attack in the left and center plots and by the mean $\mathcal { L } _ { 2 }$ pixel distance needed to fool the network using DeepFool on the right plot.
+
+![](images/638b59c88b87e39b698b1ce6757d7192e44f7cfe6affecec77d95e10a9712d1f.jpg)  
+Figure 10: Test set accuracy under different types of implementation related noise.
+
+# D.1.2 Tests with black box FGSM
+
+To further verify that the obtained results are not only due to gradient masking, we perform tests with black box FGSM, where the target attacked network is not the same as the source of the adversarial noise.
+
+For this test we set the SNR of FGSM to 33. We chose the network with the best performance for each of the tested methods. The results are depicted in Table 1. In our experiments, we found that the combination of our method with Parseval is the most robust to noise coming from other sources, while the noise created by both Parseval and our method did not generalize as well as the one created by Vanilla. This demonstrates that the improvements are not caused by gradient masking, but are caused by the increased robustness of the proposed method and Parseval’s.
+
+Table 1: Black box FGSM applied to the different methods. The most robust target for a given source is bolded, while the strongest source for a target is in italic.   
+
+<table><tr><td rowspan="2">Target</td><td colspan="4">Source</td></tr><tr><td>Vanilla</td><td>Parseval</td><td>Regularizer</td><td>Parseval +Regularizer</td></tr><tr><td>Vanilla</td><td>X</td><td>60.74</td><td>61.49</td><td>72.51</td></tr><tr><td>Parseval</td><td>57.82</td><td>X</td><td>68.21</td><td>73.87</td></tr><tr><td>Regularizer</td><td>69.72</td><td>74.96</td><td>X</td><td>73.56</td></tr><tr><td>Parseval + Regularizer</td><td>75.35</td><td>76.11</td><td>70.22</td><td>X</td></tr></table>
+
+# D.1.3 Tests with PGD adversarial data augmentation
+
+Most of our adversarial tests are performed with FGSM because of its simplicity and speed, even though it has already been shown (e.g: Madry et al. (2018)) that FGSM is weak as an attack and as a defense mechanism. Despite the fact we do not only target adversarial defense, we further stress the ability of the proposed regularizer to improve it and to combine with other methods. To this end we perform experiments against the PGD (Projected Gradient Descent) attack.
+
+PGD is an iterative version of FGSM, which run for a maximum number of iterations $_ { i t }$ or until convergence. For each iteration it moves by a distance of step in the direction of the gradient provided it does not go at a distance greater than $\epsilon$ from the original image.
+
+Our experiments show that the proposed regularizer increases robustness against a weak PGD attack (similar epsilon as our FGSM with SNR=33), but it is almost completely defeated by the PGD with the parameters from (Madry et al., 2018). The results are depicted in table 2. We also show that, as expected, FGSM training does not add significant robustness against the stronger PGD attack.
+
+Table 2: Test set accuracy on the CIFAR-10 dataset against the PGD attack with different parameters.   
+
+<table><tr><td>Model</td><td>it = 20,step=0.002,∈= 0.01</td><td>it=20,step</td><td>2 二 255,∈=</td><td>8 255</td></tr><tr><td>Vanilla</td><td>0.95%</td><td></td><td>0.02%</td><td></td></tr><tr><td>Proposed Regularizer</td><td>11.18%</td><td></td><td>0.09%</td><td></td></tr><tr><td>FGSM</td><td>5.78%</td><td></td><td>0.09%</td><td></td></tr><tr><td>FGSM + Regularizer</td><td>12.91%</td><td></td><td>0.55%</td><td></td></tr></table>
+
+As the proposed regularizer can be combined with FGSM defense, it is natural to also test it alongside PGD training. We use the parameters advised in (Madry et al., 2018): 7 iterations with $s t e p = 2 / 2 5 5$ , and $\epsilon = 8 / 2 5 5$ . The results depicted in Table 3 show that using our regularizer increases robustness of networks trained with PGD. Note that Dropout and Gaussian Noise were applied ten times to each of the networks and the results are displayed as the mean test set accuracy under these perturbations. A rate of $4 0 \%$ was used for dropout. The PGD attack uses the following parameters: $\begin{array} { r } { i t = 2 0 , s t e p = \frac { 2 } { 2 5 5 } , \epsilon = \frac { 8 } { 2 5 5 } } \end{array}$ ·
+
+Table 3: Results on the CIFAR-10 with PGD training and the hyperparameters from Appendix B.   
+
+<table><tr><td>Robustness</td><td colspan="2">Isotropic</td><td>Adversarial</td><td>Implementation</td></tr><tr><td>Model/ /TestType</td><td>SNR≈8</td><td>SNR≈15</td><td>PGD</td><td>Dropout</td></tr><tr><td>PGD Training</td><td>76.39%</td><td>71.25%</td><td>32.78%</td><td>35.20%</td></tr><tr><td>PGD Training +Regularizer</td><td>76.36%</td><td>72.26%</td><td>33.72%</td><td>55.63%</td></tr></table>
+
+# D.2 CIFAR-100
+
+We test the generality of the method using the CIFAR-100 dataset. Results are shown in Table 4 as the mean over three different initializations. Dropout and Gaussian Noise are applied ten times to each of the networks for a total of 30 different runs. An SNR of 33 is used for FGSM, and a rate of $2 5 \%$ is used for dropout. Images are normalized in the same way as the experiments with CIFAR-10. Due to time constraints we sample only $\frac { 1 } { 1 0 }$ of the images from the test set for the Deep Fool test.
+
+The proposed regularizer is the most robust on all categories, while Parseval has problems with the perturbations, despite yielding the best accuracy on the clean test set. The combination of the proposed regularizer and the parseval training method is not able to reproduce the good results from the CIFAR-10 dataset.
+
+The results shown in Table 4 are obtained using an architecture that is not performing very well on the clean test set for the CIFAR-100 dataset. We thus performed additional experiments using the WideResNet 28-10 (Zagoruyko and Komodakis, 2016) architecture, and we added standard data augmentation (random crops and random horizontal flipping) and dropout with probability of 30% after the first convolution of each residual block. We train for 200 epochs, starting with a learning rate of 0.1 and divide the learning rate by 5 in epochs 60, 120 and 160. Momentum of 0.9 is used and weight decay of 5e-4. We use the value from the Parseval paper ( $\beta = 0 . 0 0 0 3$ ) as in this case it provided better results than the one described in Section B.
+
+Table 4: Results on the CIFAR-100 dataset with the hyperparameters from Appendix B. Bolded value represent the best model on the test.   
+
+<table><tr><td>Robustness</td><td colspan="2">Isotropic</td><td colspan="2">Adversarial</td><td>Implementation</td></tr><tr><td>Model/Test Type</td><td>SNR≈8</td><td>SNR≈15</td><td>FGSM</td><td>Deep Fool</td><td>Dropout</td></tr><tr><td>Vanilla</td><td>62.38%</td><td>12.78%</td><td>5.70%</td><td>1.7E-5</td><td>8.66%</td></tr><tr><td>Parseval</td><td>63.61%</td><td>10.11%</td><td>5.85%</td><td>1.5E-5</td><td>10.61%</td></tr><tr><td>Proposed Regularizer</td><td>60.06%</td><td>21.14%</td><td>6.15%</td><td>2.9E-5</td><td>21.40%</td></tr><tr><td>Proposed + Parseval</td><td>56.64%</td><td>20.01%</td><td>4.07%</td><td>1.8E-5</td><td>9.41%</td></tr></table>
+
+Results on the WideResNet 28-10 architecture using data augmentation are shown in Table 5. We observe that the proposed method (sometimes with combinations with other methods) is still the most robust.
+
+Table 5: Results on the CIFAR-100 dataset with WideResNet 28-10.   
+
+<table><tr><td>Robustness</td><td colspan="2">Isotropic</td><td colspan="2">Adversarial</td><td>Implementation</td></tr><tr><td>Model/Test Type</td><td>SNR~8</td><td>SNR~15</td><td>FGSM</td><td>Deep Fool</td><td>Quantization</td></tr><tr><td>Vanilla</td><td>78.42%</td><td>11.68%</td><td>21.38%</td><td>5.3E-5</td><td>12.56%</td></tr><tr><td>Parseval</td><td>77.71%</td><td>12.75%</td><td>22.73%</td><td>5.7E-5</td><td>1.58%</td></tr><tr><td>Proposed Regularizer</td><td>77.33%</td><td>14.46%</td><td>23.27%</td><td>5.8E-5</td><td>17.01%</td></tr><tr><td>Proposed 十 Parseval</td><td>76.72%</td><td>20.24%</td><td>25.85%</td><td>6.9E-05</td><td>1.0%</td></tr></table>
+
+# E Impact of the proposed regularizer on the boundary
+
+We look at the impact of the proposed regularizer on the boundary region. To this end, we choose 10 pairs of points in distinct classes that are the most similar (i.e. their distance is minimal) in the input space and we look at the decision of the network function along the segment between them. The average is depicted in Figure 11. Note that the point to the left is always chosen to be the one corresponding to the decision of the network at the middle of the segment, so that the average curve is asymmetric.
+
+![](images/b7d8c4414d2dd4e96e52475da8c5a23399be49c9ae204bb71d8e0a830133fc6d.jpg)  
+Figure 11: $F ( \lambda \mathbf { x } + ( 1 - \lambda ) \mathbf { x } ^ { \prime } )$ for different methods.
+
+Interestingly, we observe that the proposed regularizer is the one for which the boundary is closest to the middle of the segments, thus proving our claim that the proposed regularizer control the boundary region.
+
+# F Regularizer pseudo-code
+
+Below in Algorithm 1 we describe how we use the proposed regularizer to compute the loss as a pseudo-code. This function receives five inputs:
+
+1. $l i s t _ { a c t i v a t i o n s }$ : the list of the intermediate features right after each call of the ReLU activation function of the network. We call these intermediate features activations $\ell$ where $\ell$ represents the depth of the network;   
+2. y: the output of the network;   
+3. s: the label signal of the batch. Otherwise said, the ground truth labels of the examples of the batch;   
+4. $m$ : the power of the Laplacian for which we wish to compute the smoothness;   
+5. $\gamma$ : the scaling coefficient of the regularizer loss.
+
+# Algorithm 1: Loss function of the regularized network
+
+# 1: procedure Smoothness(activations\`, s, m)
+
+2: $\mathbf { A } ^ { \ell } \gets$ Pairwise cosine similarity of activations\`   
+3: $\mathbf { D } ^ { \ell } \gets$ Diagonal degree matrix of $\mathbf { A } ^ { \ell }$   
+4: $\mathbf { L } ^ { \ell } \gets \mathbf { D } ^ { \ell } - \mathbf { A } ^ { \ell }$   
+5: $\sigma ^ { \ell } \gets \mathrm { T r a c e } ( \mathbf { s } ^ { \intercal } ( L ^ { \ell } ) ^ { m } \mathbf { s } )$   
+6: return σ\`   
+7: procedure $\mathrm { L o s s } ( l i s t _ { a c t i v a t i o n s } , \mathbf { y } , \mathbf { s } , m , \gamma )$   
+8: for activations\` ∈ listactivations do   
+L σ\` ← Smoothness(activations\`, s, m)   
+9: ∆ ← P\`maxi=1 |σi−σi−1|   
+10: return CategoricalCrossEntropy(s, y) + γm∆

parse/train/HJgJtT4tvB/HJgJtT4tvB.md

@@ -0,0 +1,414 @@
+# RECLOR: A READING COMPREHENSION DATASET REQUIRING LOGICAL REASONING
+
+Weihao $\mathbf { V } \mathbf { u } ^ { * }$ , Zihang Jiang∗, Yanfei Dong & Jiashi Feng   
+National University of Singapore   
+weihaoyu6@gmail.com, {jzihang, dyanfei}@u.nus.edu,   
+elefjia@nus.edu.sg
+
+# ABSTRACT
+
+Recent powerful pre-trained language models have achieved remarkable performance on most of the popular datasets for reading comprehension. It is time to introduce more challenging datasets to push the development of this field towards more comprehensive reasoning of text. In this paper, we introduce a new Reading Comprehension dataset requiring logical reasoning (ReClor) extracted from standardized graduate admission examinations. As earlier studies suggest, human-annotated datasets usually contain biases, which are often exploited by models to achieve high accuracy without truly understanding the text. In order to comprehensively evaluate the logical reasoning ability of models on ReClor, we propose to identify biased data points and separate them into EASY set while the rest as HARD set. Empirical results show that state-of-the-art models have an outstanding ability to capture biases contained in the dataset with high accuracy on EASY set. However, they struggle on HARD set with poor performance near that of random guess, indicating more research is needed to essentially enhance the logical reasoning ability of current models.1
+
+# 1 INTRODUCTION
+
+Machine reading comprehension (MRC) is a fundamental task in Natural Language Processing, which requires models to understand a body of text and answer a particular question related to the context. With success of unsupervised representation learning in NLP, language pre-training based models such as GPT-2 (Radford et al., 2019), BERT (Devlin et al., 2019), XLNet (Yang et al., 2019) and RoBERTa (Liu et al., 2019) have achieved nearly saturated performance on most of the popular MRC datasets (Rajpurkar et al., 2016; Lai et al., 2017; Rajpurkar et al., 2018; Wang et al., 2018). It is time to challenge state-of-the-art models with more difficult reading comprehension tasks and move a step forward to more comprehensive analysis and reasoning over text (Dua et al., 2019).
+
+In natural language understanding, logical reasoning is an important ability to examine, analyze and critically evaluate arguments as they occur in ordinary language according to the definition from Law School Admission Council (2019a). It is a significant component of human intelligence and is essential in negotiation, debate and writing etc. However, existing reading comprehension datasets have none or merely a small amount of data requiring logical reasoning, e.g., $0 \%$ in MCTest dataset (Richardson et al., 2013) and $1 . 2 \%$ in SQuAD (Rajpurkar et al., 2016) according to Sugawara & Aizawa (2016). One related task is natural language inference, which requires models to label the logical relationships of sentence pairs. However, this task only considers three types of simple logical relationships and only needs reasoning at sentence-level. To push the development of models in logical reasoning from simple logical relationship classification to multiple complicated logical reasoning and from sentence-level to passage-level, it is necessary to introduce a reading comprehension dataset targeting logical reasoning.
+
+A typical example of logical reasoning questions is shown in Table 1. Similar to the format of multiple-choice reading comprehension datasets (Richardson et al., 2013; Lai et al., 2017), it contains a context, a question and four options with only one right answer. To answer the question in this example, readers need to identify the logical connections between the lines to pinpoint the conflict, then understand each of the options and select an option that solves the conflict. Human minds need extensive training and practice to get used to complex reasoning, and it will take immense efforts for crowdsourcing workers to design such logical reasoning questions. Inspired by the datasets extracted from standardized examinations (Lai et al., 2017; Clark et al., 2018), we build a dataset by selecting such logical reasoning questions from standardized exams such as GMAT 2 and LSAT 3. We finally collect 6,138 pieces of logical reasoning questions, which constitute a Reading Comprehension dataset requiring logical reasoning (ReClor).
+
+Human-annotated datasets usually contain biases (Schwartz et al., 2017; Cai et al., 2017; Bugert et al., 2017; Poliak et al., 2018; Gururangan et al., 2018; Zellers et al., 2019), which are often exploited by neural network models as shortcut solutions to achieve high testing accuracy. For data points whose options can be selected correctly without knowing the contexts and questions, we classify them as biased ones. In order to fully assess the logical reasoning ability of the models, we propose to identify the biased data points and group them as EASY set, and put the rest into HARD set. Based on our experiments on these separate sets, we find that even the state-of-the-art models can only perform well on EASY set and struggle on HARD set as shown in Figure 1. This phenomenon shows that current models can well capture the biases in the dataset but lack the ability to understand the text and reason based on connections between the lines. On the other hand, human beings perform similarly on both the EASY and HARD set. It is thus observed that there is still a long way to go to equip models with true logical reasoning ability.
+
+The contributions of our paper are two-fold. First, we introduce ReClor, a new reading comprehension dataset requiring logical reasoning. We use option-only-input baselines trained with different random seeds to identify the data points with biases in the testing set, and group them as EASY set, with the rest as HARD set to facilitate comprehensive evaluation. Second, we evaluate several stateof-the-art models on ReClor and find these pre-trained language models can perform well on EASY set but struggle on the HARD set. This indicates although current models are good at exploiting biases in the dataset, they are far from capable of performing real logical reasoning yet.
+
+![](images/73c37fe1139b7b1854a789cb0914c62761596190bd5e3400d88991befeb92d98.jpg)  
+Figure 1: Performance comparison of state-of-the-art models and humans (graduate students) on EASY and HARD set of ReClor testing set.
+
+# 2 RELATED WORK
+
+Reading Comprehension Datasets. A variety of reading comprehension datasets have been introduced to promote the development of this field. MCTest (Richardson et al., 2013) is a dataset with 2,000 multiple-choice reading comprehension questions about fictional stories in the format similar to ReClor. Rajpurkar et al. (2016) proposed SQuAD dataset, which contains 107,785 questionanswer pairs on 536 Wikipedia articles. The authors manually labeled 192 examples of the dataset and found that the examples mainly require reasoning of lexical or syntactic variation. In an analysis of the above-mentioned datasets, Sugawara & Aizawa (2016) found that none of questions requiring logical reasoning in MCTest dataset (Richardson et al., 2013) and only $1 . 2 \%$ in SQuAD dataset (Rajpurkar et al., 2016). Lai et al. (2017) introduced RACE dataset by collecting the English exams for middle and high school Chinese students in the age range between 12 to 18. They hired crowd workers on Amazon Mechanical Turk to label the reasoning type of 500 samples in the dataset and show that around $70 \%$ of the samples are in the category of word matching, paraphrasing or single-sentence reasoning. To encourage progress on deeper comprehension of language,
+
+# Context:
+
+In jurisdictions where use of headlights is optional when visibility is good, drivers who use headlights at all times are less likely to be involved in a collision than are drivers who use headlights only when visibility is poor. Yet Highway Safety Department records show that making use of headlights mandatory at all times does nothing to reduce the overall number of collisions.
+
+Question: Which one of the following, if true, most helps to resolve the apparent discrepancy in the information above?
+
+# Options:
+
+A. In jurisdictions where use of headlights is optional when visibility is good, one driver in four uses headlights for daytime driving in good weather.   
+B. Only very careful drivers use headlights when their use is not legally required.   
+C. The jurisdictions where use of headlights is mandatory at all times are those where daytime visibility is frequently poor.   
+D. A law making use of headlights mandatory at all times is not especially difficult to enforce.   
+Answer: B
+
+Table 1: An example in the ReClor dataset which is modified from the Law School Admission Council (2019b).
+
+more reading comprehension datasets requiring more complicated reasoning types are introduced, such as iterative reasoning about the narrative of a story (Kocisk ˇ y et al., 2018), multi-hop reasoning \` across multiple sentences (Khashabi et al., 2018) and multiple documents (Welbl et al., 2018), commonsense knowledge reasoning (Mihaylov et al., 2018; Zhang et al., 2018; Huang et al., 2019) and numerical discrete reasoning over paragraphs (Dua et al., 2019). However, to the best of our knowledge, although there are some datasets targeting logical reasoning in other NLP tasks mentioned in the next section, there is no dataset targeting evaluating logical reasoning in reading comprehension task. This work introduces a new dataset to fill this gap.
+
+Logical Reasoning in NLP. There are several tasks and datasets introduced to investigate logical reasoning in NLP. The task of natural language inference, also known as recognizing textual entailment (Fyodorov et al., 2000; Condoravdi et al., 2003; Bos & Markert, 2005; Dagan et al., 2005; MacCartney & Manning, 2009) requires models to take a pair of sentence as input and classify their relationship types, i.e., ENTAILMENT, NEUTRAL, or CONTRADICTION. SNLI (Bowman et al., 2015) and MultiNLI (Williams et al., 2018) datasets are proposed for this task. However, this task only focuses on sentence-level logical relationship reasoning and the relationships are limited to only a few types. Another task related to logical reasoning in NLP is argument reasoning comprehension task introduced by Habernal et al. (2018) with a dataset of this task. Given an argument with a claim and a premise, this task aims to select the correct implicit warrant from two options. Although the task is on passage-level logical reasoning, it is limited to only one logical reasoning type, i.e., identifying warrants. ReClor and the proposed task integrate various logical reasoning types into reading comprehension, with the aim to promote the development of models in logical reasoning not only from sentence-level to passage-level, but also from simple logical reasoning types to the complicated diverse ones.
+
+Datasets from Examinations. There have been several datasets extracted from human standardized examinations in NLP, such as RACE dataset (Lai et al., 2017) mentioned above. Besides, NTCIR QA Lab (Shibuki et al., 2014) offers comparative evaluation for solving real-world university entrance exam questions; The dataset of CLEF QA Entrance Exams Task (Rodrigo et al., 2015) is extracted from standardized English examinations for university admission in Japan; ARC dataset (Clark et al., 2018) consists of 7,787 science questions targeting student grade level, ranging from 3rd grade to 9th; The dialogue-based multiple-choice reading comprehension dataset DREAM (Sun et al., 2019) contains 10,197 questions for 6,444 multi-turn multi-party dialogues from English language exams that are designed by human experts to assess the comprehension level of Chinese learners of English. Compared with these datasets, ReClor distinguishes itself by targeting logical reasoning.
+
+# 3 RECLOR DATA COLLECTION AND ANALYSIS
+
+# 3.1 DATA COLLECTION
+
+The format of data in ReClor is similar to other multiple-choice reading comprehension datasets (Richardson et al., 2013; Lai et al., 2017), where a data point contains a context, a question and four answer options, among which only one option is right/most suitable. We collect reading comprehension problems that require complicated logical reasoning. However, producing such data requires the ability to perform complex logical reasoning, which makes it hard for crowdsourcing workers to generate such logical questions. Fortunately, we find the reading comprehension problems in some standardized tests, such as GMAT and LSAT, are highly in line with our expectation.
+
+Table 2: Statistics of several multiple-choice MRC datasets.   
+
+<table><tr><td></td><td>ReClor</td><td>DREAM</td><td>MCTest</td><td>ARC</td><td>RACE</td></tr><tr><td>construction method</td><td>exams</td><td>exams</td><td>crowd-sourcing</td><td>exams</td><td>exams</td></tr><tr><td>context type</td><td>written text</td><td>dialogues</td><td>child&#x27;s stories</td><td>-</td><td>written text</td></tr><tr><td># of options</td><td>4</td><td>3</td><td>4</td><td>4</td><td>4</td></tr><tr><td># of context</td><td>6,138</td><td>6,444</td><td>660</td><td>-</td><td>27,933</td></tr><tr><td># of questions</td><td>6,138</td><td>10,197</td><td>2,640</td><td>7,787</td><td>97,687</td></tr><tr><td>Vocab size</td><td>26,576</td><td>13,037</td><td>8,000</td><td>6,329</td><td>136,629</td></tr><tr><td>Context Len</td><td>73.6</td><td>85.9</td><td>210.1</td><td>1</td><td>321.9</td></tr><tr><td>Question Len</td><td>17.0</td><td>8.6</td><td>7.8</td><td>20.5</td><td>10.0</td></tr><tr><td>Option Len</td><td>20.6</td><td>5.3</td><td>3.4</td><td>4.2</td><td>5.3</td></tr></table>
+
+We construct a dataset containing 6,138 logical reasoning questions sourced from open websites and books. In the original problems, there are five answer options in which only one is right. To comply with fair use of law4, we shuffle the order of answer options and randomly delete one of the wrong options for each data point, which results in four options with one right option and three wrong options. Furthermore, similar to ImageNet dataset5, ReClor is available for non-commercial research purpose only. We are also hosting a public evaluation server on EvalAI (Yadav et al., 2019) to benchmark progress on Reclor.
+
+# 3.2 DATA ANALYSIS
+
+As mentioned above, we collect 6,138 data points, in which $9 1 . 2 2 \%$ are from actual exams of GMAT and LSAT while others are from high-quality practice exams. They are divided into training set, validation set and testing set with 4,638, 500 and 1,000 data points respectively. The overall statistics of ReClor and comparison with other similar multiple-choice MRC datasets are summarized in Table 2. As shown, ReClor is of comparable size and relatively large vocabulary size. Compared with RACE, the length of the context of ReCor is much shorter. In RACE, there are many redundant sentences in context to answer a question. However, in ReClor, every sentence in the context passages is important, which makes this dataset focus on evaluating the logical reasoning ability of models rather than the ability to extract relevant information from a long context. The length of answer options of ReClor is largest among these datasets. We analyze and manually annotate the types of questions on the testing set and group them into 17 categories, whose percentages and descriptions are shown in Table 3. The percentages of different types of questions reflect those in the logical reasoning module of GMAT and LSAT. Some examples of different types of logical reasoning are listed in Figure 2, and more examples are listed in the Appendix C. Taking two examples, we further express how humans would solve such questions in Table 4, showing the challenge of ReClor.
+
+# 3.3 DATA BIASES IN THE DATASET
+
+The dataset is collected from exams devised by experts in logical reasoning, which means it is annotated by humans and may introduce biases in the dataset. Recent studies have shown that models can utilize the biases in a dataset of natural language understanding to perform well on the task without truly understanding the text (Schwartz et al., 2017; Cai et al., 2017; Bugert et al., 2017; Poliak et al., 2018; Gururangan et al., 2018; Zellers et al., 2019). It is necessary to analyze such data biases to help evaluate models. In the ReClor dataset, the common context and question are shared across the four options for each data point, so we focus on the analysis of the difference in lexical choice and sentence length of the right and wrong options without contexts and questions. We first investigate the biases of lexical choice. We lowercase the options and then use WordPiece tokenization (Wu et al., 2016) of BERTBASE (Devlin et al., 2019) to get the tokens. Similar to
+
+Table 3: The percentage and description of each logical reasoning type. The descriptions are adapted from those specified by Khan Academy (2019).   
+
+<table><tr><td>Type</td><td>Description</td></tr><tr><td>Necessary Assumptions (11.4%)</td><td>identify the claim that must be true or is required in order for the</td></tr><tr><td>Sufficient Assumptions (3.0%)</td><td>argument to work.</td></tr><tr><td></td><td>identify a sufficient assumption,that is,an assumption that,if added to the argument, would make it logically valid.</td></tr><tr><td>Strengthen (9.4%) Weaken (11.3%)</td><td>identify information that would strengthen an argument identify information that would weaken an argument</td></tr><tr><td>Evaluation (1.3%)</td><td>identify information that would be useful to know to evaluate an</td></tr><tr><td>Implication (4.6%)</td><td>argument identify something that follows logically from a set of premises</td></tr><tr><td>Conclusion/Main Point (3.6%) Most Strongly Supported (5.6%)</td><td>identify the conclusion/main point of a line of reasoning find the choice that is most strongly supported by a stimulus</td></tr><tr><td>Explain or Resolve (8.4%) Principle (6.5%)</td><td>identifyinformation that would explain orresolve a situation identify the principle,or find a situation that conforms to a princi-</td></tr><tr><td></td><td>ple,or match the principles</td></tr><tr><td>Dispute (3.0%) Technique (3.6%)</td><td>identify or infer an issue in dispute</td></tr><tr><td>Role (3.2%)</td><td>identify the technique used in the reasoning of an argument describe the individual role that a statement is playing in a larger</td></tr><tr><td>Identifya Flaw (11.7%)</td><td>argument</td></tr><tr><td>Match Flaws (3.1%)</td><td>identify a flaw in an argument&#x27;s reasoning</td></tr><tr><td></td><td>find a choice containing an argument that exhibits the same flaws</td></tr><tr><td>Match the Structure (3.0%)</td><td>as the passage&#x27;s argument</td></tr><tr><td>Others (7.3%)</td><td>match the structure of an argument in a choice to the structure of the argument in the passage</td></tr></table>
+
+Poliak et al. (2018), for the tokens in options, we analyze their conditional probability of label $l \in \{ \mathrm { r i g h t , w r o n g } \}$ given by the token $t$ by $p ( l | t ) = c o u n i ( t , l ) / c o u n t ( t )$ . The larger the correlation score is for a particular token, the more likely it contributes to the prediction of related option. Table 5 reports tokens in training set which occur at least twenty times with the highest scores since many of the tokens with the highest scores are of low frequency. We further analyze the lengths of right and wrong options (Gururangan et al., 2018) in training set. We notice a slight difference in the distribution of sentence length for right and wrong options. The average length for wrong options is around 21.82 whereas that for right options is generally longer with an average length of 23.06.
+
+Table 5: Top 10 tokens that correlate to right options with more than 20 occurrences.   
+
+<table><tr><td>Token</td><td>Score (%) Freq</td></tr><tr><td>motive</td><td>65.2 23</td></tr><tr><td>##ce</td><td>62.5 24</td></tr><tr><td>thereby</td><td>56.0 25</td></tr><tr><td>consequence</td><td>52.4 21</td></tr><tr><td>warm</td><td>52.4 21</td></tr><tr><td>interfere</td><td>52.2 23</td></tr><tr><td>contributes</td><td>52.2 23</td></tr><tr><td>manufacture</td><td>52.0 25</td></tr><tr><td>included</td><td>52.0 25</td></tr><tr><td>preferences</td><td>52.0 25</td></tr></table>
+
+![](images/4796c9678ba9cc5d70c18dec06ce0ff2831bea2b89131073dbee155f0c89ddf6.jpg)  
+Figure 3: The distribution of the option length in ReClor with respect to right and wrong labels.
+
+# 4 EXPERIMENTS
+
+# 4.1 BASELINE MODELS
+
+Many neural network based models such as FastText (Joulin et al., 2017), Bi-LSTM, GPT (Radford et al., 2018), GPT-2 (Radford et al., 2019), BERT (Devlin et al., 2019), XLNet (Yang et al., 2019),
+
+# Context:
+
+If the purpose of laws is to contribute to people’s happiness, we have a basis for criticizing existing laws as well as proposing new laws. Hence, if that is not the purpose, then we have no basis for the evaluation of existing laws, from which we must conclude that existing laws acquire legitimacy simply because they are the laws
+
+Question: The reasoning in the argument is flawed in that the argument
+
+# Options:
+
+A. takes a sufficient condition for a state of affairs to be a necessary condition for it B. draws a conclusion about how the world actually is on the basis of claims about how it should be C. infers a causal relationship from the mere presence of a correlation D. trades on the use of a term in one sense in a premise and in a different sense in the conclusion
+
+Answer: A
+
+# Reasoning Process of Humans:
+
+We may first look at the question to understand the specific task of the question – identify a flaw. We then analyze the argument in the context. The conclusion ‘existing laws acquire legitimacy simply because they are the laws.’ is based on the argument (purpose is NOT happiness) $\bf \Pi  \Pi ( N O T$ basis for criticizing laws), which is obtained from the first statement: (purpose is happiness) (basis for criticizing laws). However, we know $\neg A  \neg B$ cannot be obtained from $A  B$ . Therefore, we should choose option A that describes this flaw. The distractors here are different types of reasoning flaws. Prior knowledge of basic logical rules is needed to correctly answer this question.
+
+# Context:
+
+Psychologist: Phonemic awareness, or the knowledge that spoken language can be broken into component sounds, is essential for learning to read an alphabetic language. But one also needs to learn how sounds are symbolically represented by means of letters; otherwise, phonemic awareness will not translate into the ability to read an alphabetic language. Yet many children who are taught by the whole-language method, which emphasizes the ways words sound, learn to read alphabetic languages.
+
+Question: Which one of the following can be properly inferred from the psychologist’s statements?
+
+# Options:
+
+A. The whole-language method invariably succeeds in teaching awareness of how spoken language can be broken into component sounds.   
+B. Some children who are taught by the whole-language method are not prevented from learning how sounds are represented by means of letters.   
+C. The whole-language method succeeds in teaching many children how to represent sounds symbolically by means of letters.   
+D. When the whole-language method succeeds in teaching someone how to represent sounds by means of letters, that person acquires the ability to read an alphabetic language.
+
+Answer: B
+
+# Reasoning Process of Humans:
+
+Looking at the question and we know that it is asking about implication. From the first two sentences in context, we know that there are two necessary conditions to read an alphabetic language: phonemic awareness and symbolic letters. We also learn [(NOT symbolic letters) AND (phonemic awareness)] $\nrightarrow$ read an alphabetic language (denoted as Formula 1). The last sentence in the context says that many children are taught by the whole-language method to learn a language. As for option A, from the context, we only know the whole language method works for ‘many’ children, which cannot be inferred to ‘invariably’ works. As for option B, combing three sentences in the context, we know that the whole-language method meets the two necessary conditions to learn a language, especially the last sentence mentions ‘learn to read alphabetic languages’. Children learn to read alphabetic languages means that they must recognize symbolic letters that represent sound because symbolic letters is a necessary condition of read an alphabetic language; otherwise, they cannot read because of Formula 1 mentioned above. Therefore, option B is correct. As for option C, from the context we only know the whole-language method teaches phonemic awareness and read an alphabetic language. Symbolic letters may be taught by other methods, so C is wrong. As for D, similar to C, symbolic letters may be taught by other methods and we also cannot obtain: symbolic letters read an alphabetic language.
+
+Table 4: Two examples to show how humans would solve the questions.
+
+![](images/04b08116d5a84ed7d5a043f4bc5fcad19f24fc82b5cb2bb18708db3648beaa85.jpg)
+
+Figure 2: Examples of some question types. The correct options are marked by $\checkmark$ . More examples are shown in the Appendix C.
+
+RoBERTa (Liu et al., 2019) have achieved impressive results in various NLP tasks. We challenge these neural models with ReClor to investigate how well they can perform. Details of the baseline models and implementation are shown in the Appendix A and B.
+
+# 4.2 EXPERIMENTS TO FIND BIASED DATA
+
+As mentioned earlier, biases prevalently exist in human-annotated datasets (Poliak et al., 2018; Gururangan et al., 2018; Zellers et al., 2019; Niven & Kao, 2019), which are often exploited by models to perform well without truly understanding the text. Therefore, it is necessary to find out the biased data points in ReClor in order to evaluate models in a more comprehensive manner (Sugawara et al., 2018). To this end, we feed the five strong baseline models (GPT, GPT-2, BERTBASE, XLNetBASE and RoBERTaBASE) with ONLY THE ANSWER OPTIONS for each problem. In other words, we purposely remove the context and question in the inputs. In this way, we are able to identify those problems that can be answered correctly by merely exploiting the biases in answer options without knowing the relevant context and question. However, the setting of this task is a multiple-choice question with 4 probable options, and even a chance baseline could have $2 5 \%$ probability to get it right. To eliminate the effect of random guess, we set four different random seeds for each model and pick the data points that are predicted correctly in all four cases to form the EASY set. Then, the data points which are predicted correctly by the models at random could be nearly eliminated, since any data point only has a probability of $( \dot { 2 5 } \% ) ^ { 4 } = 0 . 3 9 \%$ to be guessed right consecutively for four times. Then we unite the sets of data points that are consistently predicted right by each model, because intuitively different models may learn different biases of the dataset. The above process is formulated as the following expression,
+
+$$
+\begin{array} { r l } & { \mathbb { C } _ { \mathrm { E A S Y } } = ( \mathbb { C } _ { \mathrm { G P T } } ^ { \mathrm { s e e d _ { 1 } } } \cap \mathbb { C } _ { \mathrm { G P T } } ^ { \mathrm { s e e d _ { 2 } } } \cap \mathbb { C } _ { \mathrm { G P T } } ^ { \mathrm { s e e d _ { 3 } } } \cap \mathbb { C } _ { \mathrm { G P T } } ^ { \mathrm { s e e d _ { 4 } } } ) } \\ & { \cup ( \mathbb { C } _ { \mathrm { G P T } - 2 } ^ { \mathrm { s e e d _ { 1 } } } \cap \mathbb { C } _ { \mathrm { G P T } - 2 } ^ { \mathrm { s e e d _ { 2 } } } \cap \mathbb { C } _ { \mathrm { G P T } - 2 } ^ { \mathrm { s e e d _ { 3 } } } \cap \mathbb { C } _ { \mathrm { G P T } - 2 } ^ { \mathrm { s e e d _ { 4 } } } ) } \\ & { \cup ( \mathbb { C } _ { \mathrm { B E R T } } ^ { \mathrm { s e e d _ { 1 } } } \cap \mathbb { C } _ { \mathrm { B E R T } } ^ { \mathrm { s e e d _ { 2 } } } \cap \mathbb { C } _ { \mathrm { B E R T } } ^ { \mathrm { s e e d _ { 3 } } } \cap \mathbb { C } _ { \mathrm { B E R T } } ^ { \mathrm { s e e d _ { 4 } } } ) } \\ & { \cup ( \mathbb { C } _ { \mathrm { X L N e t } } ^ { \mathrm { s e e d _ { 1 } } } \cap \mathbb { C } _ { \mathrm { X L N e t } } ^ { \mathrm { s e e d _ { 2 } } } \cap \mathbb { C } _ { \mathrm { X L N e t } } ^ { \mathrm { s e e d _ { 3 } } } \cap \mathbb { C } _ { \mathrm { X L N e t } } ^ { \mathrm { s e e d _ { 4 } } } ) } \\ &  \cup ( \mathbb { C } _ { \mathrm { B o B E R T a } } ^ { \mathrm { s e e d _ { 1 } } } \cap \mathbb { C } _ { \mathrm { B o B E R T a } } ^ { \mathrm { s e e d _ { 2 } } } \cap \mathbb { C } _ { \mathrm { B o B E R T a } } ^ { \mathrm { s e e d _ { 3 } } } \cap \mathbb { C } _ { \mathrm { B o B E R T a } } ^  \end{array}
+$$
+
+$$
+\mathbb { C } _ { \mathrm { H A R D } } = \mathbb { C } _ { \mathrm { T E S T } } - \mathbb { C } _ { \mathrm { E A S Y } } ,
+$$
+
+where $\mathbb { C } _ { \mathrm { B E R T } } ^ { \mathrm { s e e d } _ { 1 } }$ denotes the set of data points which are predicted correctly by BERTBASE with seed 1, and similarly for the rest. Table 6 shows the average performance for each model trained with four different random seeds and the number of data points predicted correctly by all of them. Finally, we get 440 data points from the testing set CTEST and we denote this subset as EASY set CEASY and the other as HARD set $\mathbb { C } _ { \mathrm { H A R D } }$ .
+
+<table><tr><td>Model</td><td>Val</td><td>Test</td><td>Number</td></tr><tr><td>Chance</td><td>25.0</td><td>25.0</td><td>3.9</td></tr><tr><td>GPT</td><td>45.8</td><td>42.2</td><td>238</td></tr><tr><td>GPT-2</td><td>46.8</td><td>42.6</td><td>245</td></tr><tr><td>BERTBASE</td><td>47.2</td><td>43.2</td><td>234</td></tr><tr><td>XLNetBASE</td><td>47.5</td><td>43.2</td><td>225</td></tr><tr><td>RoBERTaBASE</td><td>48.8</td><td>41.7</td><td>200</td></tr><tr><td>Union</td><td>1</td><td>1</td><td>440</td></tr></table>
+
+Table 6: Average accuracy of each model using four different random seeds with only answer options as input, and the number of their common correct predictions.
+
+# 4.3 TRANSFER LEARNING THROUGH FINE-TUNING
+
+Among multiple-choice reading comprehension or QA datasets from exams, although the size of ReClor is comparable to those of ARC (Clark et al., 2018) and DREAM (Sun et al., 2019), it is much smaller than RACE Lai et al. (2017). Recent studies (Min et al., 2017; Howard & Ruder, 2018; Huang et al., 2019; Jin et al., 2019) have shown the effectiveness of pre-training on similar tasks or datasets then fine-tuning on the target dataset for transfer learning. Jin et al. (2019) find that by first training on RACE (Lai et al., 2017) and then further fine-tuning on the target dataset, the performances of BERTBASE on multiple-choice dataset MC500 (Richardson et al., 2013) and DREAM (Sun et al., 2019) can significantly boost from $6 9 . 5 \%$ to $8 1 . 2 \%$ , and from $6 3 . 2 \%$ to $7 0 . 2 \%$ , respectively. However, they also find that the model cannot obtain significant improvement even performs worse if it is first fine-tuned on span-based dataset like $\mathrm { S Q u A D }$ (Rajpurkar et al., 2016). ReClor is a multiple-choice dataset, so we choose RACE for fine-tuning study.
+
+# 4.4 RESULTS AND ANALYSIS
+
+The performance of all tested models on the ReClor is presented in Table 7. This dataset is built on questions designed for students who apply for admission to graduate schools, thus we randomly choose 100 samples from the testing set and divide them into ten tests, which are distributed to ten different graduate students in a university. We take the average of their scores and present it as the baseline of graduate students. The data of ReClor are carefully chosen and modified from only high-quality questions from standardized graduate entrance exams. We set the ceiling performance to $100 \%$ since ambiguous questions are not included in the dataset.
+
+The performance of fastText is better than random guess, showing that word correlation could be used to help improve performance to some extent. It is difficult for Bi-LSTM to converge on this dataset. Transformer-based pre-training models have relatively good performance, close to the performance of graduate students. However, we find that these models only perform well on EASY set with around $7 5 \%$ accuracy, showing these models have an outstanding ability to capture the biases of the dataset, but they perform poorly on HARD set with only around $30 \%$ accuracy. In contrast, humans can still keep good performance on HARD set. We notice the difference in testing accuracy performed by graduate students on EASY and HARD set, but this could be due to the small number of students participated in the experiments. Therefore, we say humans perform relatively consistent on both biased and non-biased dataset.
+
+Table 7: Accuracy $( \% )$ of models and human performance. The column Input means whether to input context (C), question (Q) and answer options (A). The RACE column represents whether to first use RACE to fine-tune before training on ReClor.   
+
+<table><tr><td>Model</td><td>Input</td><td>RACE</td><td>Val</td><td>Test</td><td>Test-E</td><td>Test-H</td></tr><tr><td>Chance</td><td>(C,Q,A)</td><td></td><td>25.0</td><td>25.0</td><td>25.0</td><td>25.0</td></tr><tr><td>fastText</td><td rowspan="4">(C, Q, A)</td><td></td><td>32.0</td><td>30.8</td><td>40.2</td><td>23.4</td></tr><tr><td>Bi-LSTM</td><td></td><td>27.8</td><td>27.0</td><td>26.4</td><td>27.5</td></tr><tr><td>GPT</td><td></td><td>47.6</td><td>45.4</td><td>73.0</td><td>23.8</td></tr><tr><td>GPT-2</td><td></td><td>52.6</td><td>47.2</td><td>73.0</td><td>27.0</td></tr><tr><td>BERTBASE</td><td>(C,Q,A) (C,Q，A)</td><td>√</td><td>54.6 55.2</td><td>47.3</td><td>71.6</td><td>28.2</td></tr><tr><td rowspan="4">BERTLARGE</td><td>(A)</td><td></td><td>46.4</td><td>49.5 42.4</td><td>68.9 69.3</td><td>34.3 21.3</td></tr><tr><td>(Q,A)</td><td></td><td>48.8</td><td></td><td></td><td></td></tr><tr><td></td><td></td><td>53.8</td><td>43.4 49.8</td><td>72.7</td><td>20.4</td></tr><tr><td>(C, Q,A) (C,Q,A)</td><td>√</td><td></td><td></td><td>72.0</td><td>32.3</td></tr><tr><td rowspan="2">XLNetBASE</td><td>(C,Q，,A)</td><td></td><td>55.6 55.8</td><td>54.5 50.4</td><td>73.9</td><td>39.3</td></tr><tr><td>(C,Q,A)</td><td>√</td><td>62.0</td><td>55.5</td><td>75.2 76.1</td><td>30.9 39.3</td></tr><tr><td rowspan="4">XLNetLARGE</td><td>(A)</td><td></td><td>45.0</td><td>42.9</td><td>66.1</td><td>24.6</td></tr><tr><td>(Q,A)</td><td></td><td>47.8</td><td>43.4</td><td>68.6</td><td></td></tr><tr><td>(C, Q,A)</td><td></td><td>62.0</td><td>56.0</td><td>75.7</td><td>23.6</td></tr><tr><td>(C,Q，A)</td><td>√</td><td>70.8</td><td>62.4</td><td></td><td>40.5</td></tr><tr><td rowspan="2">RoBERTaBASE</td><td>(C,Q,A)</td><td></td><td></td><td></td><td>77.7</td><td>50.4</td></tr><tr><td>(C,Q,A)</td><td>√</td><td>55.0</td><td>48.5</td><td>71.1</td><td>30.7</td></tr><tr><td rowspan="4">RoBERTaLARGE</td><td></td><td></td><td>56.8</td><td>53.0</td><td>72.5</td><td>37.7</td></tr><tr><td>(A)</td><td></td><td>48.8</td><td>43.2</td><td>69.5</td><td>22.5</td></tr><tr><td>(Q，A)</td><td></td><td>49.8</td><td>45.8</td><td>72.0</td><td>25.2</td></tr><tr><td>(C,Q, A) (C,Q，A)</td><td>厂</td><td>62.6</td><td>55.6</td><td>75.5</td><td>40.0</td></tr><tr><td>Graduate Students</td><td>(C,Q,A)</td><td></td><td>68.0</td><td>65.1 63.0</td><td>78.9 57.1</td><td>54.3 67.2</td></tr><tr><td>Ceiling Performance</td><td>(C, Q, A)</td><td></td><td>二 1</td><td>100</td><td>100</td><td>100</td></tr></table>
+
+It is noticed that if the models are first trained on RACE and then fine-tuned on ReClor, they could obtain significant improvement, especially on HARD set. The overall performance of RoBERTaLARGE is even better than that of graduate students. This similar phenomenon can also be observed on DREAM dataset (Sun et al., 2019) by Jin et al. (2019), which shows the potential of transfer learning for reasoning tasks. However, even after fine-tuning on RACE, the best performance of these strong baselines on HARD set is around $50 \%$ , still lower than that of graduate students and far away from ceiling performance.
+
+Experiments in different input settings are also done. Compared with the input setting of answer options only (A), the setting of questions and answer options (Q, A) can not bring significant improvement. This may be because some questions e.g., Which one of the following is an assumption required by the argument?, Which one of the following, if true, most strengthens the argument? can be used in the same reasoning types of question, which could not offer much information. Further adding context causes significant boost, showing the high informativeness of the context.
+
+We further analyze the model performance with respect to different question types of logical reasoning. Some results are shown in Figure 4 and the full results are shown in Figure 5, 6 and 7 in the Appendix E. Three models of BERTLARGE, XLNetLARGE and RoBERTaLARGE perform well on most of types. On HARD set, the three models perform poorly on certain types such as STRENGTHEN, WEAKEN and ROLE which require extensive logical reasoning. However, they perform relatively better on other certain types, such as CONCLUSION/MAIN POINT and MATCH STRUCTURES that are more straight-forward. For the result of transfer learning, we analyze XLNetLARGE in detail. Though the overall performance is significantly boosted after fine-tuning on RACE first, the histograms in the bottom of Figure 4 show that on EASY set, accuracy of the model with fine-tuning on RACE is similar to that without it among most question types, while on HARD set, significant improvement on some question types is observed, such as CONCLUSION/MAIN POINT and MOST STRONGLY SUPPORTED. This may be because these types require less logical reasoning to some extent compared with other types, and similar question types may also be found in RACE dataset. Thus, the pre-training on RACE helps enhance the ability of logical reasoning especially of relatively simple reasoning types, but more methods are still needed to further enhance the ability especially that of relatively complex reasoning types.
+
+![](images/e083725fb155bf267a03657aab056067a6cca61deb50ce58dc1681dd890d7856.jpg)  
+Figure 4: Performance of models on EASY (left) and HARD (right) testing sets and that of models. XLNetLARGE +Fine-Tune means the model is first fine-tuned on RACE before training on ReClor.
+
+# 5 CONCLUSION
+
+In this paper, we introduce ReClor, a reading comprehension dataset requiring logical reasoning, with the aim to push research progress on logical reasoning in NLP forward from sentence-level to passage-level and from simple logical reasoning to multiple complicated one. We propose to identify biased data points and split the testing set into EASY and HARD group for biased and non-biased data separately. We further empirically study the different behaviors of state-of-the-art models on these two testing sets, and find recent powerful transformer-based pre-trained language models have an excellent ability to exploit the biases in the dataset but have difficulty in understanding and reasoning given the non-biased data with low performance close to or slightly better than random guess. These results show there is a long way to equip deep learning models with real logical reasoning abilities. We hope this work would inspire more research in future to adopt similar split technique and evaluation scheme when reporting their model performance. We also show by first fine-tuning on a large-scale dataset RACE then fine-tuning on ReClor, the models could obtain significant improvement, showing the potential of transfer learning to solve reasoning tasks.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank the anonymous reviewers for their insightful comments and suggestions; thank Rishabh Jain from Georgia Tech for helping build up the leaderboard of ReClor on EvalAI. Jiashi Feng was partially supported by NUS IDS R-263-000-C67-646, ECRA R-263-000-C87-133, MOE Tier-II R-263-000-D17-112 and AI.SG R-263-000-D97-490. Weihao Yu and Zihang Jiang would like to thank TFRC program for the support of computational resources.
+
+# REFERENCES
+
+Common crawl. http://http://commoncrawl.org, 2019.
+
+Khan Academy. https://www.khanacademy.org/test-prep/lsat/lsat-lessons/ logical-reasoning/a/logical-reasoning--article--question-typecatalog, 2019. Accessed Sept. 16, 2019.
+
+Johan Bos and Katja Markert. Recognising textual entailment with logical inference. In Proceedings of the conference on Human Language Technology and Empirical Methods in Natural Language Processing, pp. 628–635. Association for Computational Linguistics, 2005.
+
+Samuel R Bowman, Gabor Angeli, Christopher Potts, and Christopher D Manning. A large annotated corpus for learning natural language inference. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pp. 632–642, 2015.
+
+Michael Bugert, Yevgeniy Puzikov, Andreas Ruckl ¨ e, Judith Eckle-Kohler, Teresa Martin, Eugenio ´ Mart´ınez-Camara, Daniil Sorokin, Maxime Peyrard, and Iryna Gurevych. Lsdsem 2017: Explor- ´ ing data generation methods for the story cloze test. In Proceedings of the 2nd Workshop on Linking Models of Lexical, Sentential and Discourse-level Semantics, pp. 56–61, 2017.
+
+Zheng Cai, Lifu Tu, and Kevin Gimpel. Pay attention to the ending: Strong neural baselines for the roc story cloze task. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers), pp. 616–622, 2017.
+
+Jamie Callan, Mark Hoy, Changkuk Yoo, and Le Zhao. Clueweb09 data set, 2009.
+
+Peter Clark, Isaac Cowhey, Oren Etzioni, Tushar Khot, Ashish Sabharwal, Carissa Schoenick, and Oyvind Tafjord. Think you have solved question answering? try arc, the ai2 reasoning challenge. arXiv preprint arXiv:1803.05457, 2018.
+
+Cleo Condoravdi, Dick Crouch, Valeria De Paiva, Reinhard Stolle, and Daniel G Bobrow. Entailment, intensionality and text understanding. In Proceedings of the HLT-NAACL 2003 workshop on Text meaning, pp. 38–45, 2003.
+
+Law School Admission Council. https://www.lsac.org/lsat/taking-lsat/testformat/logical-reasoning, 2019a. Accessed Sept. 16, 2019.
+
+Law School Admission Council. https://www.lsac.org/lsat/taking-lsat/testformat/logical-reasoning/logical-reasoning-sample-questions, 2019b. Accessed Sept. 16, 2019.
+
+Ido Dagan, Oren Glickman, and Bernardo Magnini. The pascal recognising textual entailment challenge. In Machine Learning Challenges Workshop, pp. 177–190. Springer, 2005.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pp. 4171–4186, 2019.
+
+Dheeru Dua, Yizhong Wang, Pradeep Dasigi, Gabriel Stanovsky, Sameer Singh, and Matt Gardner. Drop: A reading comprehension benchmark requiring discrete reasoning over paragraphs. In Proceedings of NAACL-HLT, pp. 2368–2378, 2019.
+
+Yaroslav Fyodorov, Yoad Winter, and Nissim Francez. A natural logic inference system. In Proceedings of the 2nd Workshop on Inference in Computational Semantics (ICoS-2). Citeseer, 2000.
+
+Suchin Gururangan, Swabha Swayamdipta, Omer Levy, Roy Schwartz, Samuel R Bowman, and Noah A Smith. Annotation artifacts in natural language inference data. arXiv preprint arXiv:1803.02324, 2018.
+
+Ivan Habernal, Henning Wachsmuth, Iryna Gurevych, and Benno Stein. The argument reasoning comprehension task: Identification and reconstruction of implicit warrants. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pp. 1930–1940, 2018.
+
+Jeremy Howard and Sebastian Ruder. Universal language model fine-tuning for text classification. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 328–339, 2018.
+
+Lifu Huang, Ronan Le Bras, Chandra Bhagavatula, and Yejin Choi. Cosmos qa: Machine reading comprehension with contextual commonsense reasoning. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pp. 2391–2401, 2019.
+
+Di Jin, Shuyang Gao, Jiun-Yu Kao, Tagyoung Chung, and Dilek Hakkani-tur. Mmm: Multi-stage multi-task learning for multi-choice reading comprehension. arXiv preprint arXiv:1910.00458, 2019.
+
+Armand Joulin, Edouard Grave, Piotr Bojanowski, and Tomas Mikolov. Bag of tricks for efficient text classification. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 2, Short Papers, pp. 427–431. Association for Computational Linguistics, April 2017.
+
+Daniel Khashabi, Snigdha Chaturvedi, Michael Roth, Shyam Upadhyay, and Dan Roth. Looking beyond the surface: A challenge set for reading comprehension over multiple sentences. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pp. 252–262, 2018.
+
+Toma´s Ko ˇ cisk ˇ y, Jonathan Schwarz, Phil Blunsom, Chris Dyer, Karl Moritz Hermann, G \` abor Melis, ´ and Edward Grefenstette. The narrativeqa reading comprehension challenge. Transactions of the Association for Computational Linguistics, 6:317–328, 2018.
+
+Guokun Lai, Qizhe Xie, Hanxiao Liu, Yiming Yang, and Eduard Hovy. Race: Large-scale reading comprehension dataset from examinations. arXiv preprint arXiv:1704.04683, 2017.
+
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019.
+
+Bill MacCartney and Christopher D Manning. An extended model of natural logic. In Proceedings of the eighth international conference on computational semantics, pp. 140–156. Association for Computational Linguistics, 2009.
+
+Todor Mihaylov, Peter Clark, Tushar Khot, and Ashish Sabharwal. Can a suit of armor conduct electricity? a new dataset for open book question answering. arXiv preprint arXiv:1809.02789, 2018.
+
+Sewon Min, Minjoon Seo, and Hannaneh Hajishirzi. Question answering through transfer learning from large fine-grained supervision data. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers), pp. 510–517, 2017.
+
+Timothy Niven and Hung-Yu Kao. Probing neural network comprehension of natural language arguments. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, pp. 4658–4664, 2019.
+
+Robert Parker, David Graff, Junbo Kong, Ke Chen, and Kazuaki Maeda. English gigaword fifth edition, 2011.
+
+Jeffrey Pennington, Richard Socher, and Christopher Manning. Glove: Global vectors for word representation. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pp. 1532–1543, 2014.
+
+Adam Poliak, Jason Naradowsky, Aparajita Haldar, Rachel Rudinger, and Benjamin Van Durme. Hypothesis only baselines in natural language inference. In Proceedings of the Seventh Joint Conference on Lexical and Computational Semantics, pp. 180–191, 2018.
+
+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/researchcovers/languageunsupervised/language understanding paper. pdf, 2018.
+
+Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. OpenAI Blog, 1(8), 2019.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: $1 0 0 { , } 0 0 0 { + }$ questions for machine comprehension of text. arXiv preprint arXiv:1606.05250, 2016.
+
+Pranav Rajpurkar, Robin Jia, and Percy Liang. Know what you don’t know: Unanswerable questions for squad. arXiv preprint arXiv:1806.03822, 2018.
+
+Matthew Richardson, Christopher JC Burges, and Erin Renshaw. Mctest: A challenge dataset for the open-domain machine comprehension of text. In Proceedings of the 2013 Conference on Empirical Methods in Natural Language Processing, pp. 193–203, 2013.
+
+Alvaro Rodrigo, Anselmo Penas, Yusuke Miyao, Eduard H Hovy, and Noriko Kando. Overview of clef qa entrance exams task 2015. In CLEF (Working Notes), 2015.
+
+Roy Schwartz, Maarten Sap, Ioannis Konstas, Leila Zilles, Yejin Choi, and Noah A Smith. Story cloze task: Uw nlp system. In Proceedings of the 2nd Workshop on Linking Models of Lexical, Sentential and Discourse-level Semantics, pp. 52–55, 2017.
+
+Hideyuki Shibuki, Kotaro Sakamoto, Yoshinobu Kano, Teruko Mitamura, Madoka Ishioroshi, Kelly Y Itakura, Di Wang, Tatsunori Mori, and Noriko Kando. Overview of the ntcir-11 qa-lab task. In Ntcir, 2014.
+
+Saku Sugawara and Akiko Aizawa. An analysis of prerequisite skills for reading comprehension. In Proceedings of the Workshop on Uphill Battles in Language Processing: Scaling Early Achievements to Robust Methods, pp. 1–5, 2016.
+
+Saku Sugawara, Kentaro Inui, Satoshi Sekine, and Akiko Aizawa. What makes reading comprehension questions easier? In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pp. 4208–4219, 2018.
+
+Kai Sun, Dian Yu, Jianshu Chen, Dong Yu, Yejin Choi, and Claire Cardie. Dream: A challenge data set and models for dialogue-based reading comprehension. Transactions of the Association for Computational Linguistics, 7:217–231, 2019.
+
+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.
+
+Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel Bowman. Glue: A multi-task benchmark and analysis platform for natural language understanding. In Proceedings of the 2018 EMNLP Workshop BlackboxNLP: Analyzing and Interpreting Neural Networks for NLP, pp. 353–355, 2018.
+
+Johannes Welbl, Pontus Stenetorp, and Sebastian Riedel. Constructing datasets for multi-hop reading comprehension across documents. Transactions of the Association for Computational Linguistics, 6:287–302, 2018.
+
+Adina Williams, Nikita Nangia, and Samuel Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pp. 1112–1122, 2018.
+
+Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016.
+
+Deshraj Yadav, Rishabh Jain, Harsh Agrawal, Prithvijit Chattopadhyay, Taranjeet Singh, Akash Jain, Shiv Baran Singh, Stefan Lee, and Dhruv Batra. Evalai: Towards better evaluation systems for ai agents. arXiv preprint arXiv:1902.03570, 2019.
+
+Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, and Quoc V Le. Xlnet: Generalized autoregressive pretraining for language understanding. arXiv preprint arXiv:1906.08237, 2019.
+
+Rowan Zellers, Ari Holtzman, Yonatan Bisk, Ali Farhadi, and Yejin Choi. Hellaswag: Can a machine really finish your sentence? arXiv preprint arXiv:1905.07830, 2019.
+
+Sheng Zhang, Xiaodong Liu, Jingjing Liu, Jianfeng Gao, Kevin Duh, and Benjamin Van Durme. Record: Bridging the gap between human and machine commonsense reading comprehension. arXiv preprint arXiv:1810.12885, 2018.
+
+Yukun Zhu, Ryan Kiros, Rich Zemel, Ruslan Salakhutdinov, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. Aligning books and movies: Towards story-like visual explanations by watching movies and reading books. In Proceedings of the IEEE international conference on computer vision, pp. 19–27, 2015.
+
+# A BASELINE MODELS
+
+fastText. FastText (Joulin et al., 2017) models sentences as a bag of n-grams, and tries to predict the probability of each answer being correct independently. We choose the answer with the highest score as the prediction for the multiple-choice setting.
+
+LSTM sentence encoder. A two-layer bi-LSTM is randomly initialized as a sentence encoder with GloVe word embedding (Pennington et al., 2014). With a span of text as input, the last hidden state of the second layer is max-pooled and then fed into a fully-connected layer to compute the output score.
+
+GPT and GPT-2. GPT (Radford et al., 2018) and GPT-2 (Radford et al., 2019) are both transformer (Vaswani et al., 2017) based models which are pre-trained using unsupervised method with a standard language modeling objective. GPT is pre-trained on BooksCorpus; GPT-2 is pre-trained using a larger dataset called WebText. Here we use the smallest model proposed in (Radford et al., 2019) as our GPT-2 baseline. To fine-tune on ReClor, the final hidden vector corresponding to the last input token ([ classify ]) is used as the aggregate representation followed by an extra fully connected layer to compute the score.
+
+BERT. BERT (Devlin et al., 2019) is also a transformer (Vaswani et al., 2017) based model which is trained by using BooksCorpus (Zhu et al., 2015) and English Wikipedia in two unsupervised tasks, i.e., Masked LM (MLM) and Next Sentence Prediction (NSP). During fine-tuning, the final hidden vector corresponding to the first input token ([CLS]) is used as the aggregate representation followed by two extra fully connected layers to compute the score.
+
+XLNet. XLNet (Yang et al., 2019) is trained with Permutation Language Modeling and without NSP. In addition, beside BooksCorpus and English Wikipedia used in BERT, it uses Giga5 (Parker et al., 2011), ClueWeb 2012-B (extended from (Callan et al., 2009)), and Common Crawl (com, 2019) for pre-training. We use the final hidden vector corresponding to the last input token ${ \mathrm { < c l s > } }$ as the aggregate representation and introduce two fully connected layers to predict the score.
+
+RoBERTa. RoBERTa (Liu et al., 2019) is an improved pre-training procedure of BERT with training the model longer, with bigger batches over more data and removing NSP objective etc.. Extra two fully connected layers are added to transform the final hidden vector of the first input token ( $< S >$ to the score.
+
+The input format of different models is shown in Table 8.
+
+<table><tr><td>Model</td><td colspan="4">Input Format</td></tr><tr><td>GPTRadford etal. (2018)</td><td></td><td>_start_Context _delimiter-Question</td><td>Option</td><td>-classify-</td></tr><tr><td>GPT-2 Radford et al. (2019)</td><td></td><td>-start-Context _delimiter- Question</td><td>二 Option</td><td>-classify-</td></tr><tr><td>BERT(Devlin et al.,2019)</td><td></td><td>[CLS] Context [SEP] Question Il</td><td>Option [SEP]</td><td>[PAD]...</td></tr><tr><td>XLNet (Yang et al.,2019)</td><td>&lt;pad&gt;...</td><td>Context &lt;sep&gt; Question |l Option &lt;sep&gt; &lt;cls&gt;</td><td></td><td></td></tr><tr><td>RoBERTa (Liu et al., 2019)</td><td></td><td>&lt;s&gt; Context &lt;/s&gt; &lt;/s&gt; Question Il Option &lt;/s&gt; &lt;pad&gt;...</td><td></td><td></td></tr></table>
+
+Table 8: Input formats of different models. Context, Question and Option represent the token sequences of the context, question and option respectively, and || denotes concatenation.
+
+# B IMPLEMENTATION DETAIL
+
+Adam is used by all models. For fastText, we use its python library6 by converting ReClor to the required form, and keep the default setting of the hyper parameters. For Bi-LSTM, we use a twolayer Bidirectional LSTM with the GloVe 300d word embedding (Pennington et al., 2014) followed by max-pooling and a fully-connected layer. We train the model for 100 epochs using a batch size of 64 and learning rate of 0.1. A learning rate decay of 0.5 is also applied every 10 epochs. For pre-training models, we modify the code of Transformers of Hugging Face7 to implement them on ReClor. We use a batch size of 24 and fine-tune for 10 epochs. The maximum input sequence length for all models is 256. The detailed hyperparameters are shown in Table 9.
+
+Table 9: Hyperparameters for finetuning pre-training language models on ReClor   
+
+<table><tr><td>HYPERPARAM</td><td>GPT</td><td>GPT-2</td><td>BERTBASE</td><td>BERTLARGE</td><td>XLNetBASE</td><td>XLNetLARGE</td><td>RoBERTaBASE</td><td>RoBERTaLARGE</td></tr><tr><td>LearningRate Batch Size</td><td>6.25e-5</td><td>6.25e-5</td><td>2e-5</td><td>2e-5</td><td>2e-5 24</td><td>2e-5</td><td>1e-5</td><td>1e-5</td></tr><tr><td>Max Seq Length Learning Rate Decay</td><td></td><td></td><td></td><td></td><td>256 Linear</td><td></td><td></td><td></td></tr><tr><td>Number of Epochs Warm-up Proportion</td><td></td><td></td><td></td><td></td><td>10 0.1</td><td></td><td></td><td></td></tr><tr><td>Weight Decay</td><td>0.01</td><td>0.01</td><td>0.0</td><td>0.0</td><td>0.01</td><td>0.01</td><td>0.01</td><td>0.01</td></tr><tr><td>Adam Epsilon</td><td>1e-8</td><td>1e-8</td><td>1e-6</td><td>1e-6</td><td>1e-6</td><td>1e-6</td><td>1e-6</td><td>1e-6</td></tr><tr><td>Adam Betas Clip Grad Norm</td><td>(0.9,0.999)</td><td>(0.9,0.999)</td><td>(0.9,0.999)</td><td>(0.9,0.999)</td><td>(0.9,0.999) Not</td><td>(0.9,0.999)</td><td>(0.9,0.98)</td><td>(0.9,0.98)</td></tr></table>
+
+# C EXAMPLES
+
+Table 10: The definition and an example of the logical reasoning type - Necessary Assumptions   
+
+<table><tr><td>Type:Necessary Assumptions Definition: identify the claim that must be true or is required in order for the argument to work</td></tr><tr><td>Context: Slash-and-burn agriculture involves burning several acres of forest,leaving vegetable ash that provides ample fertilizer for three or four years of bountiful crops.On the cleared land nutrients leach out of the soil,however,and the land becomes too poor to support agriculture. New land is then cleared by burning and the process starts again.Since most farming in the tropics uses this method,forests in this region will</td></tr><tr><td>eventually be permanently eradicated. Question: The argument depends on the assumption that</td></tr><tr><td>Options: A.forests in the tropics do not regenerate well enough to restore themselves once they have been cleared</td></tr><tr><td>by the slash-and-burn method B.some other methods of agriculture are not as destructive to the environment in tropical regions as the</td></tr><tr><td></td></tr><tr><td>slash-and-burn method is C.forests in the tropics are naturally deficient in nutrients that are needed to support the growth of plants</td></tr></table>
+
+Table 11: The definition and an example of the logical reasoning type - Sufficient Assumptions   
+
+<table><tr><td>Type:Sufficient Assumptions Definition: identify a sufficient assumption,that is,an assumption that, if added to the argument, would make it logically valid</td></tr><tr><td>Context: Geologist: A new method for forecasting earthquakes has reliably predicted several earthquakes. Unfor- tunately,this method can predict only that an earthquake willfall somewhere within a range of two and a half points on the Richter scale.Thus,since a difference of two and a half points can be the difference</td></tr><tr><td>between a marginally perceptible shaking and a quake that causes considerable damage,the new method is unlikely to be useful. Question:Which one of the follwing,if assumed,enables the geologist&#x27;s conclusion to be properly</td></tr><tr><td>inferred? Options:</td></tr><tr><td>A. An earthquake-forecasting method is unlikely to be useful unless its predictions always differentiate earthquakes that are barely noticeable from ones that result in substantial destruction. B.Several wel-established methods for forecasting earthquakes can predict within much narrower ranges</td></tr><tr><td>than two and a half points on the Richter scale. C.Even if an earthquake-forecasting method makes predictions within a very narrow range on the Richter scale,this method is not likely to be useful unless its predictions are reliable.</td></tr></table>
+
+Table 12: The definition and an example of the logical reasoning type - Strengthen   
+
+<table><tr><td>Type:Strengthen Definition: identify information that would strengthen an argument</td></tr><tr><td>Context: Financial success does not guarantee happiness.This claim is not mere proverbial wisdom but a fact verified by statistics. In a recently concluded survey,only one-third of the respondents who claimed to</td></tr><tr><td>have achieved financial success reported that they were happy. Question:Which one of the following,if true,most strongly supports the conclusion drawn from the survey results?</td></tr><tr><td>Options: A.Most of the respondents who reported they were unhappy were in fact happy.</td></tr><tr><td>B.The respondents who reported financial success were,for the most part, financially successful.</td></tr><tr><td>C.Many of the respondents who claimed not to have achieved financial success reported that they were happy five years ago. D.Many of the respondents who failed to report financial success were in fact financially successful.</td></tr></table>
+
+Table 13: The definition and an example of the logical reasoning type - Weaken   
+
+<table><tr><td>Type:Weaken Definition: identify information that would weaken an argument</td></tr><tr><td>Context: “DNA fingerprinting” is a recently-introduced biochemical procedure that uses a pattrn derived from a person&#x27; s genetic material to match a suspect’ s genetic material against that of a specimen from a crime scene.Proponents have claimed astronomically high odds against obtaining a match by chance alone.</td></tr><tr><td>These odds are based on an assumption that there is independence between the diferent characteristics represented by a single pattern.</td></tr><tr><td>Question:Which one of the following,if true,casts the most doubt on the claim of the proponents of DNA fingerprinting? Options:</td></tr><tr><td>A. The skil required of laboratory technicians performing the DNA fingerprinting procedure is not ex- traordinary. B.There is a generally accepted theoretical basis for interpreting the pattrns produced by the procedure.</td></tr><tr><td>C.In the whole population there are various different subgroups,within each of which certain sets of</td></tr><tr><td>genetic characteristics are shared. D.In the investigation of certain genetic diseases,the techniques used in DNA fingerprinting have traced</td></tr></table>
+
+Table 14: The definition and an example of the logical reasoning type - Evaluation   
+
+<table><tr><td>Type:Evaluation Definition: identify information that would be useful to know to evaluate an argument</td></tr><tr><td>Context: George: Some scientists say that global warming willoccur because people are releasing large amounts of carbon dioxide into the atmosphere by burning trees and fossil fuels.We can see,though,that the predicted</td></tr><tr><td>warming is occurring already.In the middle of last winter, we had a month of springlike weather in our area,and this fall,because of unusually mild temperatures,the leaves on our town’ s trees were three weeks late in turning color.</td></tr><tr><td>Question: Which one of the following would it be most relevant to investigate in evaluating the conclusion of George&#x27;s argument?</td></tr><tr><td>Options:</td></tr><tr><td>A.whether air pollution is causing some trees in the area to lose their leaves</td></tr><tr><td>B.what proportion of global emissions of carbon dioxide is due to the burning of trees by humans</td></tr></table>
+
+Table 15: The definition and an example of the logical reasoning type - Implication   
+
+<table><tr><td>Type:Implication Definition:identify something that follows logically from a set of premises</td></tr><tr><td>Context: To be horrific,a monster must be threatening.Whether or not it presents psychological, moral or social dangers,or triggers enduring infantile fears,if a monster is physically dangerous then it is threatening.In</td></tr><tr><td>fact,even a physically benign monster is horrific if it inspires revulsion. Question:Which one of the following logically follows from the statements above?</td></tr><tr><td>Options:</td></tr><tr><td>A.Any horror-story monster that is threatening is also horrific. B.If a monster triggers infantile fears but is not physically dangerous,then it is not horrific.</td></tr><tr><td>C. All monsters that are not physically dangerous,but that are psychologically dangerous and inspire revulsion,are threatening.</td></tr></table>
+
+Table 16: The definition and an example of the logical reasoning type - Conclusion/Main Point   
+
+<table><tr><td>Type: Conclusion/Main Point Definition: identify the conclusion/main point of a line of reasoning</td></tr><tr><td>Context: Whether or not one can rightfully call a person’s faithfulness a virtue depends in part on the object of that person’s faithfulness.Virtues are by definition praiseworthy,which is why no one considers resentment virtuous,even though it is in facta kind of faithfulness-faithfulness to hatreds or animosities.</td></tr><tr><td>Question: Which one of the following most accurately expresses the overall conclusion drawn in the argument?</td></tr><tr><td>Options: A.The object of a person&#x27;s faithfulness partially determines whether or not that faithfulness is virtuous.</td></tr><tr><td>B.Virtuous behavior is praiseworthy by definition.</td></tr><tr><td>C.Resentment should not be considered a virtuous emotion.</td></tr><tr><td>D.Behavior that emerges from hatred or animosity cannot be called virtuous. Answer:A</td></tr></table>
+
+<table><tr><td>Type:Most Strongly Supported Definition: find the choice that is most strongly supported by a stimulus</td></tr><tr><td>Context: After a nuclear power plant accident,researchers found radioactive isotopes of iodine,tellurium,and cesium-but no heavy isotopes-in the atmosphere downwind. This material came either from spent fuel rods or from the plant’ s core. Spent fuel rods never contain significant quantities of telurium isotopes. Radioactive material ejected into the atmosphere directly from the core would include heavy isotopes.</td></tr><tr><td>After the accident,steam, which may have been in contact with the core,was released from the plant. The core contains iodine,tellurium,and cesium isotopes,which are easily dissolved by steam.</td></tr><tr><td>Question: Of the following statements,which one is most strongly supported by the information above? Options:</td></tr><tr><td>A. The nuclear power plant&#x27;s spent fuel rods were not damaged.</td></tr><tr><td>B.Spent fuel rods do not contain heavy isotopes in significant quantities.</td></tr><tr><td></td></tr><tr><td>C.The researchers found some radioactive material from spent fuel rods as wellas some material that was</td></tr><tr><td>ejected into the atmosphere directly from the plant&#x27;s core. D.The radioactive material detected by the researchers was carried into the atmosphere by the steam that was released from the plant.</td></tr></table>
+
+Table 17: The definition and an example of the logical reasoning type - Most Strongly Supported
+
+<table><tr><td>Type:Explain or Resolve Definition: identify information that would explain or resolve a situation</td></tr><tr><td>Context: To reduce the mosquito population in a resort area, hundreds of trees were planted that bear fruit attractive to birds. Over the years,as the trees matured,they atracted a variety of bird species and greatly increased the summer bird population in the area. As expected,the birds ate many mosquitoes.However, the</td></tr><tr><td>planting of the fruit trees had the very opposite of its intended effect. Question: Which one of the following,if true, most helps to explain the apparently paradoxical result?</td></tr><tr><td>Options: A. Most of the species of birds that were atracted by the trees that were planted did not eat mosquitoes.</td></tr><tr><td>B.Increases and decreases in mosquito populations tend to follow a cyclical pattern. C.The species of birds that were attracted in the greatest number by the fruit of the trees that were planted</td></tr><tr><td>did not eat mosquitoes. D.The birds attracted to the area by the trees ate many more insects that prey on mosquitoes than they did mosquitoes.</td></tr></table>
+
+Table 18: The definition and an example of the logical reasoning type - Explain or Resolve
+
+Table 19: The definition and an example of the logical reasoning type - Principle   
+
+<table><tr><td>Type:Principle Definition: identify the principle,or find a situation that conforms to a principle,or match the principles</td></tr><tr><td>Context: Buying elaborate screensavers - programs that put moving images on a computer monitor to prevent</td></tr><tr><td>damage-can cost a company far more in employee time than it saves in electricity and monitor protection. Employees cannot resist spending time playing with screensavers that flash interesting graphics across</td></tr><tr><td>their screens. Question:</td></tr><tr><td>Which one of the following most closely conforms to the principle illustrated above?</td></tr><tr><td>Options:</td></tr><tr><td>A.An electronic keyboard may be cheaper to buy than a piano but more expensive to repair. B.An energy-efficient insulation system may cost more up front but will ultimately save money over the</td></tr><tr><td>life of the house. C.The time that it takes to have a pizza delivered may be longer than it takes to cook a complete dinner.</td></tr><tr><td></td></tr><tr><td></td></tr><tr><td>D.A complicated hotel security system may cost more in customer goodwillthan it saves in losses by</td></tr><tr><td>theft. Answer: D</td></tr></table>
+
+Table 20: The definition and an example of the logical reasoning type - Dispute   
+
+<table><tr><td>Type:Dispute Definition: identify or infer an issue in dispute</td></tr><tr><td>Context: Raphaela: Forcing people to help others is morally wrong. Therefore, no government has the right to redistribute resources via taxation. Anyone who wants can help others voluntarily. Edward: Governments</td></tr><tr><td>do have that right, insofar as they give people the freedom to leave and hence not to live under their authority.</td></tr><tr><td>Question: Raphaela and Edward disagree about the truth of which one of the following?</td></tr><tr><td>Options:</td></tr><tr><td>A.Any government that forces people to help others should permit emigration.</td></tr><tr><td>B.Any government that permits emigration has the right to redistribute resources via taxation.</td></tr><tr><td>C.Any government that redistributes resources via taxation forces people to help others. D.Every government should allow people to help others voluntarily.</td></tr></table>
+
+Table 21: The definition and an example of the logical reasoning type - Technique   
+
+<table><tr><td>Type:Technique Definition: identify the technique used in the reasoning of an argument</td></tr><tr><td>Context: Joanna: The only way for a company to be successful,after emerging from bankruptcy, is to produce the same goods or services that it did before going bankrupt.It is futile for such a company to try to learn a</td></tr><tr><td>whole new business.Ruth: Wrong. The Kelton Company was a major mining operation that went into bankruptcy. On emerging from bankruptcy, Kelton turned its mines into landfils and is presently a highly successful waste-management concern.</td></tr><tr><td>Question:</td></tr><tr><td>Ruth uses which one of the following argumentative techniques in countering Joanna&#x27;s argument? Options:</td></tr><tr><td>A. She undermines a claim by showing that it rests on an ambiguity.</td></tr><tr><td>B.She offers an alternative explanation for a phenomenon.</td></tr><tr><td>C. She presents a counterexample to a claim. D.She establishes a conclusion by excluding the only plausible alternative to that conclusion.</td></tr></table>
+
+Answer: C
+
+Table 22: The definition and an example of the logical reasoning type - Role   
+
+<table><tr><td>Type: Role Definition: describe the individual role that a statement is playing in a larger argument</td></tr><tr><td>Context: The position that punishment should be proportional to how serious the offense is but that repeat offenders should receive harsher punishments than first-time offenders is unsustainable.It implies that considera-</td></tr><tr><td>tions as remote as what an offender did years ago are relevant to the seriousness of an offense. If such remote considerations were relevant,almost every other consideration would be too.But this would make determining the seriousness of an offense so diffcult that it would be impossible to apply the proportion-</td></tr><tr><td>ality principle. Question: The statement that considerations as remote as what an offender did years ago are relevant to the serious-</td></tr><tr><td>ness of an offense plays which one of the following roles in the argument? Options: A.It is an allegedly untenable consequence of a view rejected in the argument&#x27;s overallconclusion.</td></tr><tr><td></td></tr><tr><td>B.It is a statement the argument provides grounds to accept and from which the overall conclusion is</td></tr><tr><td>inferred.</td></tr></table>
+
+# Answer: A
+
+<table><tr><td>Type:Identifya Flaw Definition: identify a flaw in an argument&#x27;s reasoning</td></tr><tr><td>Context: The tidal range at a particular location is the difference in height between high tide and low tide.Tidal studies have shown that one of the greatest tidal ranges in the world is found in the Bay of Fundy and</td></tr><tr><td>reaches more than seventeen meters. Since the only forces involved in inducing the tides are the sun&#x27; s and moon’ s gravity,the magnitudes of tidal ranges also must be explained entirely by gravitational forces. Question:</td></tr><tr><td>Which one of the following most accurately describes a flaw in the reasoning above? Options:</td></tr><tr><td>A.It does not differentiate between the tidal effect of the sun and the tidal effect of the moon.</td></tr><tr><td>B.It fails to consider that the size of a tidal range could be afected by the conditions in which gravitational</td></tr><tr><td>forces act.</td></tr><tr><td>C.It presumes, without providing warrant, that most activity within the world&#x27;s oceans is a result of an interplay of gravitational forces.</td></tr></table>
+
+Table 23: The definition and an example of the logical reasoning type - Identify a Flaw
+
+Table 24: The definition and an example of the logical reasoning type - Match Flaws   
+
+<table><tr><td>Type:Match Flaws Definition: find a choice containing an argument that exhibits the same flaws as the passage&#x27;s argument</td></tr><tr><td>Context: The museum’ s night security guard maintains that the thieves who stole the portrait did not enter the museum at any point at or above ground level. Therefore,the thieves must have gained access to the</td></tr><tr><td>museum from below ground level. Question:</td></tr><tr><td>The flawed pattern of reasoning in the argument above is most similar to that in which one of the follow- ing？ Options:</td></tr><tr><td>A.As had generally ben expected, not all questionnaires were sent inby the official deadline.It follows that plans must have been made for the processing of questionnaires received late.</td></tr><tr><td>B. The store&#x27;s competitors claim that the store,in selling off the shirts at those prices, neither made any profit nor broke even. Consequently,the store&#x27;s customers must have been able to buy shirts there at less</td></tr><tr><td>than the store&#x27;s cost.</td></tr><tr><td>C.The product label establishes that this insecticide is safe for both humans and pets.Therefore,the insecticide must also be safe for such wild mammals as deer and rabbits. D.If the census is to be believed,the percentage of men who are married is higher than the percentage of</td></tr></table>
+
+<table><tr><td>Type:Match the Structure Definition: match the structure of an argument in a choice to the structure of the argument in the passage</td></tr><tr><td>Context: It is an absurd idea that whatever artistic endeavor the government refuses to support it does not allow, as one can see by rephrasing the statement to read: No one is allowed to create art without a government</td></tr><tr><td>subsidy. Question:</td></tr><tr><td>The pattern of reasoning in which one of the following is most similar to that in the argument above? Options:</td></tr><tr><td>A.The notion that every scientist who has been supported by a government grant will be successful is</td></tr><tr><td>absurd,as one can see by rewording it:No scientist is alowed to do research without a government grant.</td></tr><tr><td>B.The notion that every scientist who is supported by a government grant willbe successful is absurd,as one can see by rewording it:No scientist lacking governmental support will be successful.</td></tr><tr><td>C.The claim that any driver who is not arrested does not break the law is absurd,as one can see by rewording it: Every driver who gets arrested has broken the law. D.The claim that any driver who is not arrested does not break the law is absurd,as one can see by</td></tr></table>
+
+Table 25: The definition and an example of the logical reasoning type - Match the Structure
+
+Table 26: The definition and an example of the logical reasoning type - Others   
+
+<table><tr><td>Type:Others Definition: other types of questions which are not included by the above</td></tr><tr><td>Context: PhishCo runs a number of farms in the arid province of Nufa,depending largely on irrigation. Now, as part of a plan to effciently increase the farms‘ total production, it plans to drill down toan aquifer containing warm,slightly salty water that will be used to raise fish in ponds.The water from the ponds willater be used to supplement piped-in irrigation water for PhishCo&#x27;s vegetable fields,and the ponds and accompanying vegetation should help reduce the heat in the area of the farms.</td></tr><tr><td>Question: Which of the following would,if true,most strongly suggest that the plan,if implemented, would increase</td></tr><tr><td>the overall efficiency of PhishCo&#x27;s farms? Options: A. Organic waste from fish in the pond water will help to fertilize fields where it is used for irrigation. B.Fish raised on PhishCo&#x27;s farms are likely to be saleable in the nearest urban areas.</td></tr></table>
+
+Answer: A
+
+# D CONSISTENCY OF DIFFERENT MODELS
+
+Table 27: Overlap of each pair of models after intersection among 4 random seeds.   
+
+<table><tr><td></td><td>GPT</td><td>GPT-2</td><td>BERTBASE</td><td>XLNetBASE</td><td>RoBERTaBASE</td></tr><tr><td>GPT</td><td>245</td><td>164</td><td>152</td><td>142</td><td>116</td></tr><tr><td>GPT-2</td><td></td><td>238</td><td>151</td><td>144</td><td>123</td></tr><tr><td>BERTBASE</td><td></td><td></td><td>234</td><td>138</td><td>124</td></tr><tr><td>XLNetBASE</td><td></td><td></td><td></td><td>225</td><td>125</td></tr><tr><td>RoBERTaBASE</td><td></td><td></td><td></td><td></td><td>200</td></tr></table>
+
+# E RESULTS WITH RESPECT TO DIFFERENT QUESTION TYPES
+
+![](images/2b5251caae746b22a26626ec2e94591e24dbc2a9dc557edc021ec0ca46866899.jpg)  
+Figure 5: Accuracy of all baseline models on overall testing set
+
+![](images/92c817e8ab4a54e8d46a34a2fbd77a4d6d17deb82263bb8b8d659db3f8be4bf0.jpg)  
+Figure 6: Accuracy of all baseline models on EASY set of testing set
+
+![](images/f629dcda200e72860803191f1bcaf4038b701e3482ba790f08d930fd2b661349.jpg)  
+Figure 7: Accuracy of all baseline models on HARD set of testing set
+
+![](images/d0d8f9a7c2c07a0bad936a8dfa36eea062e15a52ad0f6f86cbc0be9ad8abfee5.jpg)  
+Figure 8: Performance of BERTLARGE (top) and RoBERTaLARGE (bottom) on EASY (left) and HARD (right) testing sets.

parse/train/YwpZmcAehZ/YwpZmcAehZ.md

@@ -0,0 +1,313 @@
+# REVISITING DYNAMIC CONVOLUTION VIA MATRIX DECOMPOSITION
+
+Yunsheng $\mathbf { L i ^ { 1 } }$ , Yinpeng Chen2, Xiyang Dai2, Mengchen Liu2, Dongdong Chen2, Ye $\mathbf { Y } \mathbf { u } ^ { 2 }$ , Lu Yuan2, Zicheng $\mathbf { L i u } ^ { 2 }$ , Mei Chen2, Nuno Vasconcelos1
+
+1 Department of Electrical and Computer Engineering, University of California San Diego 2 Microsoft yul554@ucsd.edu, {yiche,xidai,mengcliu,dochen}@microsoft.com {Yu.Ye,luyuan,zliu,Mei.Chen}@microsoft.com, nvasconcelos@ucsd.edu
+
+# ABSTRACT
+
+Recent research in dynamic convolution shows substantial performance boost for efficient CNNs, due to the adaptive aggregation of $K$ static convolution kernels. It has two limitations: (a) it increases the number of convolutional weights by $K$ - times, and (b) the joint optimization of dynamic attention and static convolution kernels is challenging. In this paper, we revisit it from a new perspective of matrix decomposition and reveal the key issue is that dynamic convolution applies dynamic attention over channel groups after projecting into a higher dimensional latent space. To address this issue, we propose dynamic channel fusion to replace dynamic attention over channel groups. Dynamic channel fusion not only enables significant dimension reduction of the latent space, but also mitigates the joint optimization difficulty. As a result, our method is easier to train and requires significantly fewer parameters without sacrificing accuracy. Source code is at https://github.com/liyunsheng13/dcd.
+
+# 1 INTRODUCTION
+
+Dynamic convolution (Yang et al., 2019; Chen et al., 2020c) has recently become popular for the implementation of light-weight networks (Howard et al., 2017; Zhang et al., 2018b). Its ability to achieve significant performance gains with negligible computational cost has motivated its adoption for multiple vision tasks (Su et al., 2020; Chen et al., 2020b; Ma et al., 2020; Tian et al., 2020). The basic idea is to aggregate multiple convolution kernels dynamically, according to an input dependent attention mechanism, into a convolution weight matrix
+
+$$
+{ W } ( { \pmb x } ) = \sum _ { k = 1 } ^ { K } { \pi } _ { k } ( { \pmb x } ) { W } _ { k } \quad \mathrm { s . t . } \quad 0 \leq { \pi } _ { k } ( { \pmb x } ) \leq 1 , \sum _ { k = 1 } ^ { K } { \pi } _ { k } ( { \pmb x } ) = 1 ,
+$$
+
+where $K$ convolution kernels $\{ W _ { k } \}$ are aggregated linearly with attention scores $\{ \pi _ { k } ( \pmb x ) \}$
+
+Dynamic convolution has two main limitations: (a) lack of compactness, due to the use of $K$ kernels, and (b) a challenging joint optimization of attention scores $\{ \pi _ { k } ( \pmb x ) \}$ and static kernels $\{ W _ { k } \}$ . Yang et al. (2019) proposed the use of a sigmoid layer to generate attention scores $\{ \pi _ { k } ( \pmb x ) \}$ , leading to a significantly large space for the convolution kernel $W ( { \pmb x } )$ that makes the learning of attention scores $\{ \pi _ { k } ( \pmb { x } ) \}$ difficult. Chen et al. (2020c) replaced the sigmoid layer with a softmax function to compress the kernel space. However, small attention scores $\pi _ { k }$ output by the softmax make the corresponding kernels $W _ { k }$ difficult to learn, especially in early training epochs, slowing training convergence. To mitigate these limitations, these two methods require additional constraints. For instance, Chen et al. (2020c) uses a large temperature in the softmax function to encourage nearuniform attention.
+
+In this work, we revisit the two limitations via matrix decomposition. To expose the limitations, we reformulate dynamic convolution in terms of a set of residuals, re-defining the static kernels as
+
+$$
+W _ { k } = W _ { 0 } + \Delta W _ { k } , \quad k \in \{ 1 , \dots , K \}
+$$
+
+![](images/37bcad854ab5107fa0603b86e9d44ef280f13e0cb573e308edbfa0cc7ad8f34e.jpg)  
+Figure 1: Dynamic convolution via matrix decomposition. Left: Reformulating the vanilla dynamic convolution by matrix decomposition (see Eq. 3). It applies dynamic attention $\mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \pi \mathbf { \Pi } \mathbf { \Pi } \left( \pmb { x } \right)$ over channel groups in a high dimensional space $( S V ^ { \bar { T } } { \pmb x } ~ \in ~ \mathbb { R } ^ { \pmb { \dot { K } } \pmb { \dot { C } } } ,$ ). Right: proposed dynamic convolution decomposition, which applies dynamic channel fusion $\Phi ( { \pmb x } )$ in a low dimensional space ${ \bf \nabla } Q ^ { T } { \bf x } \in$ $\mathbb { R } ^ { L }$ , $L \ll C )$ , resulting in a more compact model.
+
+where $\begin{array} { r } { { W _ { 0 } } = \frac { 1 } { K } \sum _ { k = 1 } ^ { K } W _ { k } } \end{array}$ is the average kernel and $\Delta W _ { k } = W _ { k } - W _ { 0 }$ a residual weight matrix. Further decomposing the latter with an SVD, $\Delta W _ { k } = U _ { k } S _ { k } V _ { k } ^ { T }$ , leads to
+
+$$
+\boldsymbol { W } ( \boldsymbol { x } ) = \sum _ { k = 1 } ^ { K } \pi _ { k } ( \boldsymbol { x } ) \boldsymbol { W } _ { 0 } + \sum _ { k = 1 } ^ { K } \pi _ { k } ( \boldsymbol { x } ) \boldsymbol { U } _ { k } \boldsymbol { S } _ { k } \boldsymbol { V } _ { k } ^ { T } = \boldsymbol { W } _ { 0 } + \boldsymbol { U } \boldsymbol { \Pi } ( \boldsymbol { x } ) \boldsymbol { S } \boldsymbol { V } ^ { T } ,
+$$
+
+where $U = [ U _ { 1 } , \dots , U _ { K } ]$ , ${ \pmb S } = d i a g ( { \pmb S } _ { 1 } , \ldots , { \pmb S } _ { K } )$ , $V = [ V _ { 1 } , \dots , V _ { K } ]$ , and $\mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \pi \mathbf { \Pi } \mathbf { \Pi } \left( \pmb { x } \right)$ stacks attention scores diagonally as $\Pi ( { \pmb x } ) = d i a g ( \pi _ { 1 } ( { \pmb x } ) { \pmb I } , \ldots , \pi _ { K } ( { \pmb x } ) { \pmb I } )$ , where $\pmb { I }$ is an identity matrix. This decomposition, illustrated in Figure $^ { 1 , }$ shows that the dynamic behavior of $W ( { \pmb x } )$ is implemented by the dynamic residual $U \mathbf { I I } ( \mathbf { \bar { x } } ) S V ^ { T }$ , which projects the input $_ { \textbf { \em x } }$ to a higher dimensional space $\Dot { S V } ^ { T } x$ (from $C$ to $K C$ channels), applies dynamic attention $\Pi ( x )$ over channel groups, and reduces the dimension back to $C$ channels, through multiplication by $U$ . This suggests that the limitations of vanilla dynamic convolution are due to the use of attention over channel groups, which induces a high dimensional latent space, leading to small attention values that may suppress the learning of the corresponding channels.
+
+To address this issue, we propose a dynamic convolution decomposition (DCD), that replaces dynamic attention over channel groups with dynamic channel fusion. The latter is based on a full dynamic matrix $\Phi ( { \pmb x } )$ , of which each element $\phi _ { i , j } ( \pmb { x } )$ is a function of input $_ { \textbf { \em x } }$ . As shown in Figure 1-(right), the dynamic residual is implemented as the product $P \Phi ( { \pmb x } ) Q ^ { T }$ of $\Phi ( { \pmb x } )$ and two static matrices $P , Q$ , such that $Q$ compresses the input into a low dimensional latent space, $\Phi ( { \pmb x } )$ dynamically fuses the channels in this space, and $_ { P }$ expands the number of channels to the output space. The key innovation is that dynamic channel fusion with $\Phi ( { \pmb x } )$ enables a significant dimensionality reduction of the latent space $Q ^ { T } { \pmb x } \in \mathbb { R } ^ { L }$ , $L \ll C$ ). Hence the number of parameters in $P , Q$ is significantly reduced, when compared to $U , V$ of Eq. 3, resulting in a more compact model. Dynamic channel fusion also mitigates the joint optimization challenge of vanilla dynamic convolution, as each column of $P , Q$ is associated with multiple dynamic coefficients of $\Phi ( { \pmb x } )$ . Hence, a few dynamic coefficients of small value are not sufficient to suppress the learning of static matrices $P , Q$ . Experimental results show that DCD both significantly reduces the number of parameters and achieves higher accuracy than vanilla dynamic convolution, without requiring the additional constraints of (Yang et al., 2019; Chen et al., 2020c).
+
+# 2 RELATED WORK
+
+Efficient CNNs: MobileNet (Howard et al., 2017; Sandler et al., 2018; Howard et al., 2019) decomposes $k \times k$ convolution into a depthwise and a pointwise convolution. ShuffleNet (Zhang et al., 2018b; Ma et al., 2018) uses group convolution and channel shuffle to further simplify pointwise convolution. Further improvements of these architectures have been investigated recently. EfficientNet (Tan & Le, 2019a; Tan et al., 2020) finds a proper relationship between input resolution and width/depth of the network. Tan & Le (2019b) mix up multiple kernel sizes in a single convolution. Chen et al. (2020a) trades massive multiplications for much cheaper additions. Han et al. (2020) applies a series of cheap linear transformations to generate ghost feature maps. Zhou et al. (2020) flips the structure of inverted residual blocks to alleviate information loss. Yu et al. (2019) and Cai et al. (2019) train one network that supports multiple sub-networks of different complexities.
+
+Matrix Decomposition: Lebedev et al. (2014) and Denton et al. (2014) use Canonical Polyadic decomposition (CPD) of convolution kernels to speed up networks, while Kim et al. (2015) investigates Tucker decompositions for the same purpose. More recently, Kossaifi et al. (2020) combines tensor decompositions with MobileNet to design efficient higher-order networks for video tasks, while Phan et al. (2020) proposes a stable CPD to deal with degeneracies of tensor decompositions during network training. Unlike DCD, which decomposes a convolutional kernel dynamically by adapting the core matrix to the input, these works all rely on static decompositions.
+
+Dynamic Neural Networks: Dynamic networks boost representation power by adapting parameters or activation functions to the input. Ha et al. (2017) uses a secondary network to generate parameters for the main network. Hu et al. (2018) reweights channels by squeezing global context. Li et al. (2019) adapts attention over kernels of different sizes. Dynamic convolution (Yang et al., 2019; Chen et al., 2020c) aggregates multiple convolution kernels based on attention. Ma et al. (2020) uses grouped fully connected layer to generate convolutional weights directly. Chen et al. (2020b) extends dynamic convolution from spatial agnostic to spatial specific. Su et al. (2020) proposes dynamic group convolution that adaptively selects input channels to form groups. Tian et al. (2020) applies dynamic convolution to instance segmentation. Chen et al. (2020d) adapts slopes and intercepts of two linear functions in ReLU (Nair & Hinton, 2010; Jarrett et al., 2009).
+
+# 3 DYNAMIC CONVOLUTION DECOMPOSITION
+
+In this section, we introduce the dynamic convolution decomposition proposed to address the limitations of vanilla dynamic convolution. For conciseness, we assume a kernel $W$ with the same number of input and output channels $C _ { i n } = C _ { o u t } = C \mathrm { \rangle }$ and ignore bias terms. We focus on $1 \times 1$ convolution in this section and generalize the procedure to $k \times k$ convolution in the following section.
+
+# 3.1 REVISITING VANILLA DYNAMIC CONVOLUTION
+
+Vanilla dynamic convolution aggregates $K$ convolution kennels $\{ W _ { k } \}$ with attention scores $\{ \pi _ { k } ( \pmb x ) \}$ (see Eq. 1). It can be reformulated as adding a dynamic residual to a static kernel, and the dynamic residual can be further decomposed by SVD (see Eq. 3), as shown in Figure 1. This has two limitations. First, the model is not compact. Essentially, $i t$ expands the number of channels by a factor of $K$ and applies dynamic attention over $K$ channel groups. The dynamic residual $U \mathbf { I I } ( \mathbf { \dot { x } } ) S V ^ { T }$ is a $C \times C$ matrix, of maximum rank $C$ , but sums $K C$ rank-1 matrices, since
+
+$$
+\pmb { W } ( \pmb { x } ) = \pmb { W } _ { 0 } + \pmb { U } \pmb { \Pi } ( \pmb { x } ) \pmb { S } \pmb { V } ^ { T } = \pmb { W } _ { 0 } + \sum _ { i = 1 } ^ { K C } \pi _ { \uparrow i / C | } ( \pmb { x } ) \pmb { u } _ { i } s _ { i , i } \pmb { v } _ { i } ^ { T } ,
+$$
+
+where $\mathbf { \Delta } \mathbf { u } _ { i }$ is the $i ^ { t h }$ column vector of matrix $U$ , ${ \mathbf { } } v _ { i }$ is the $i ^ { t h }$ column vector of matrix $V$ , $s _ { i , i }$ is the $i ^ { t h }$ diagonal entry of matrix $_ { s }$ and $\lceil \cdot \rceil$ is ceiling operator. The static basis vectors $\mathbf { \Delta } \mathbf { u } _ { i }$ and ${ \mathbf { } } v _ { i }$ are not shared across different rank-1 matrices $( \pi _ { \lceil i / C \rceil } ( \pmb { x } ) \pmb { u } _ { i } s _ { i , i } \pmb { v } _ { i } ^ { T } )$ . This results in model redundancy. Second, it is difficult to jointly optimize static matrices $U$ , $V$ and dynamic attention $\mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \mathbf { \Pi } \pi \mathbf { \Pi } \mathbf { \Pi } \left( \pmb { x } \right)$ . This is because a small attention score $\pi _ { \lceil i / C \rceil }$ may suppress the learning of corresponding columns $\mathbf { \Delta } \mathbf { u } _ { i }$ , ${ \mathbf { } } v _ { i }$ in $U$ and $V$ , especially in early training epochs (as shown in Chen et al. (2020c)).
+
+# 3.2 DYNAMIC CHANNEL FUSION
+
+We propose to address the limitations of the vanilla dynamic convolution with a dynamic channel fusion mechanism, implemented with a full matrix $\Phi ( { \pmb x } )$ , where each element $\phi _ { i , j } ( \pmb { x } )$ is a function of input $_ { \textbf { \em x } }$ . $\Phi ( { \pmb x } )$ is a $L \times L$ matrix, dynamically fusing channels in the latent space $\mathbb { R } ^ { L }$ . The key idea is to significantly reduce dimensionality in the latent space, $L \ll C$ , to enable a more compact model. Dynamic convolution is implemented with dynamic channel fusion using
+
+$$
+\pmb { W } ( \pmb { x } ) = \pmb { W } _ { 0 } + \pmb { P } \pmb { \Phi } ( \pmb { x } ) \pmb { Q } ^ { T } = \pmb { W } _ { 0 } + \sum _ { i = 1 } ^ { L } \sum _ { j = 1 } ^ { L } \pmb { p } _ { i } \phi _ { i , j } ( \pmb { x } ) \pmb { q } _ { j } ^ { T } ,
+$$
+
+where $Q \in \mathbb { R } ^ { C \times L }$ compresses the input into a low dimensional space $( Q ^ { T } \pmb { x } \in \mathbb { R } ^ { L } )$ , the resulting $L$ channels are fused dynamically by $\bar { \Phi } ( { \boldsymbol { x } } ) \in \mathbb { R } ^ { L \times L }$ and expanded to the number of output channels by $\pmb { P } \in \mathbb { R } ^ { C \times L }$ . This is denoted as dynamic convolution decomposition (DCD). The dimension $L$ of the latent space is constrained by $\dot { L } ^ { 2 } < C$ . The default value of $L$ in this paper is empirically set to b Cblog √Cc c, which means dividing C by 2 repeatedly until it is less than C.
+
+With this new design, the number of static parameters is significantly reduced (i.e. $L C$ parameters in $_ { r }$ or $\textit { \textbf { Q } } \nu . s$ . $K C ^ { 2 }$ parameters in $U$ or $V$ , $L ~ < ~ \sqrt { C } )$ , resulting in a more compact model. Mathematically, the dynamic residual $P \Phi ( { \pmb x } ) Q ^ { T }$ sums $L ^ { 2 }$ rank-1 matrices ${ \pmb p } _ { i } \phi _ { i , j } ( { \pmb x } ) { \pmb q } _ { j } ^ { T }$ , where $\mathbf { \nabla } _ { \mathbf { p } _ { i } }$ is the $i ^ { t h }$ column vector of $_ { r }$ , and $\pmb q _ { j }$ is the $j ^ { t h }$ column vector of $Q$ . The constraint $L ^ { 2 } < C$ , guarantees that this number $( L ^ { 2 } )$ is much smaller than the counterpart $( K C )$ of vanilla dynamic convolution (see Eq. 4). Nevertheless, due to the use of a full matrix, dynamic channel fusion $\Phi ( { \pmb x } )$ retains the representation power needed to achieve good classification performance.
+
+DCD also mitigates the joint optimization difficulty. Since each column of $_ { r }$ (or $Q$ ) is associated with multiple dynamic coefficients (e.g. $\mathbf { \nabla } p _ { i }$ is related to $\phi _ { i , 1 } , \ldots , \phi _ { i , L } )$ , it is unlikely that the learning of $\pmb { p } _ { i }$ is suppressed by a few dynamic coefficients of small value.
+
+In summary, DCD performs dynamic aggregation differently from vanilla dynamic convolution. Vanilla dynamic convolution uses a shared dynamic attention mechanism to aggregate unshared static basis vectors in a high dimensional latent space. In contrast, DCD uses an unshared dynamic channel fusion mechanism to aggregate shared static basis vectors in a low dimensional latent space.
+
+# 3.3 MORE GENERAL FORMULATION
+
+So far, we have focused on the dynamic residual and shown that dynamic channel fusion enables a compact implementation of dynamic convolution. We next discuss the static kernel $W _ { 0 }$ . Originally, it is multiplied by a dynamic scalar $\textstyle \sum _ { k } \pi _ { k } ( { \pmb x } )$ , which is canceled in Eq. 3 as attention scores sum to one. Relaxing the constraint $\begin{array} { r } { \sum _ { k } \pi _ { k } ( \mathbf { \bar { x } } ) = 1 } \end{array}$ results in the more general form
+
+$$
+\pmb { W } ( \pmb { x } ) = \pmb { \Lambda } ( \pmb { x } ) \pmb { W } _ { 0 } + \pmb { P } \pmb { \Phi } ( \pmb { x } ) \pmb { Q } ^ { T } ,
+$$
+
+where $\pmb { \Lambda } ( \pmb { x } )$ is a $C \times C$ diagonal matrix and $\lambda _ { i , i } ( \pmb { x } )$ a function of $_ { \textbf { \em x } }$ . In this way, $\pmb { \Lambda } ( \pmb { x } )$ implements channel-wise attention after the static kernel $W _ { 0 }$ , generalizing Eq. 5 where $\pmb { \Lambda } ( \pmb { x } )$ is an identity matrix. Later, we will see that this generalization enables additional performance gains.
+
+Relation to Squeeze-and-Excitation (SE) (Hu et al., 2018): The dynamic channel-wise attention mechanism implemented by $\pmb { \Lambda } ( \pmb { x } )$ is related to but different from SE. It is parallel to a convolution and shares the input with the convolution. It can be thought of as either a dynamic convolution kernel ${ \pmb y } = ( { \pmb \Lambda } ( { \pmb x } ) { \pmb W } _ { 0 } ) { \pmb x }$ or an input-dependent attention mechanism applied to the output feature map of the convolution ${ \pmb y } = { \pmb \Lambda } ( { \pmb x } ) ( { \pmb W } _ { 0 } { \pmb x } )$ . Thus, its computational complexity is $\operatorname* { m i n } ( \mathcal { O } ( C ^ { 2 } ) , \mathcal { O } ( H W C ) )$ , where $H$ and $W$ are height and width of the feature map.
+
+In contrast, SE is placed after a convolution and uses the output of the convolution as input. It can only apply channel attention on the output feature map of the convolution as $y = \pmb { \Lambda } ( z ) z$ , where $z = W _ { 0 } { \pmb x }$ . Its computational complexity is $\mathcal { O } ( H W C )$ . Clearly, SE requires more computation than dynamic channel-wise attention $\pmb { \Lambda } ( \pmb { x } )$ when the resolution of the feature map $( H \times W )$ is high.
+
+# 3.4 DYNAMIC CONVOLUTION DECOMPOSITION LAYER
+
+Implementation: Figure 2 shows the diagram of a dynamic convolution decomposition (DCD) layer. It uses a light-weight dynamic branch to generate coefficients for both dynamic channel-wise attention $\pmb { \Lambda } ( \pmb { x } )$ and dynamic channel fusion $\Phi ( { \pmb x } )$ . Similar to Squeeze-and-Excitation (Hu et al., 2018), the dynamic branch first applies average pooling to the input $_ { \textbf { \em x } }$ . This is followed by two fully connected (FC) layers with an activation layer between them. The first FC layer reduces the number of channels by $r$ and the second expands them into $C + L ^ { 2 }$ outputs $C$ for $\pmb { \Lambda }$ and $L ^ { 2 }$ for $\Phi$ ). Eq. 6 is finally used to generate convolutional weights $W ( { \pmb x } )$ . Similarly to a static convolution, a DCD layer also includes a batch normalization and an activation (e.g. ReLU) layer.
+
+Parameter Complexity: DCD has similar FLOPs to the vanilla dynamic convolution. Here, we focus on parameter complexity. Static convolution and vanilla dynamic convolution require $C ^ { 2 }$ and $K C ^ { 2 }$ parameters, respectively. DCD requires $C ^ { 2 }$ , $C L$ , and $C L$ parameters for static matrices $W _ { 0 }$ , $_ { P }$ and $Q$ , respectively. An additional $( 2 C + L ^ { 2 } ) \frac { C } { r }$ parameters are required by the dynamic branch to generate $\pmb { \Lambda } ( \pmb { x } )$ and $\Phi ( { \pmb x } )$ , where $r$ is the reduction rate of the first FC layer. The total complexity is $\begin{array} { r } { C ^ { 2 } + 2 C L + ( 2 C + L ^ { 2 } ) \frac { C } { r } } \end{array}$ . Since $L$ is constrained as $L ^ { 2 } < C$ , the complexity upper bound is $( 1 + \textstyle { \frac { 3 } { r } } ) C ^ { 2 } + 2 C \sqrt { C }$ . When choosing $r = 1 6$ , the complexity is about $1 \frac { 3 } { 1 6 } C ^ { 2 }$ . This is much less than what is typical for vanilla dynamic convolution ( $\mathrm { 4 } C ^ { 2 }$ in Chen et al. (2020c) and $8 C ^ { 2 }$ in Yang et al. (2019)).
+
+![](images/095999c82ca5e0d58772ecf92bdc8c6fe722550a4713cd3785573d0e790c9fc8.jpg)  
+Figure 2: Dynamic convolution decomposition layer. The input $_ { \textbf { \em x } }$ first goes through a dynamic branch to generate $\pmb { \Lambda } ( \pmb { x } )$ and $\Phi ( { \pmb x } )$ , and then to generate the convolution matrix $W ( { \pmb x } )$ using Eq. 6.
+
+![](images/6834050855ca91a52cf123cbc6cce2dc0b03af42aa810758a845d0d9d321091d.jpg)  
+Figure 3: Sparse dynamic residual, which is represented as a diagonal block matrix. Each diagonal block is decomposed separately as $\bar { P } _ { b } \Phi _ { b } Q _ { b } ^ { T }$ . Note that the static kernel $W _ { 0 }$ is still a full size matrix.
+
+# 4 EXTENSIONS OF DYNAMIC CONVOLUTION DECOMPOSITION
+
+In this section, we extend the dynamic decomposition of $1 \times 1$ convolution (Eq. 6) in three ways: (a) sparse dynamic residual where $P \Phi ( { \pmb x } ) Q ^ { \dagger }$ is a diagonal block matrix, (b) $k \times k$ depthwise convolution, and (c) $k \times k$ convolution. Here, $k$ refers to the kernel size.
+
+# 4.1 DCD WITH SPARSE DYNAMIC RESIDUAL
+
+The dynamic residual $P \Phi ( { \pmb x } ) Q ^ { T }$ can be further simplified into a block-diagonal matrix of blocks $P _ { b } \Phi _ { b } ( { \boldsymbol { x } } ) Q _ { b } ^ { T } , b \in \{ 1 , . . . , \dot { B } \}$ , leading to
+
+$$
+W ( \pmb { x } ) = \Lambda ( \pmb { x } ) W _ { 0 } + \bigoplus _ { b = 1 } ^ { B } P _ { b } \Phi _ { b } ( \pmb { x } ) Q _ { b } ^ { T } ,
+$$
+
+where $\bigoplus _ { i = 1 } ^ { n } A _ { i } = d i a g ( A _ { 1 } , \ldots , A _ { n } )$ . This form has Eq. 6 as a special case, where $B = 1$ . Note that the static kernel $W _ { 0 }$ is still a full matrix and only the dynamic residual is sparse (see Figure 3). We will show later that keeping as few as $\frac { 1 } { 8 }$ of the entries of the dynamic residual non-zero ( $B = 8$ ) has a minimal performance degradation, still significantly outperforming a static kernel.
+
+# 4.2 DCD OF $k \times k$ DEPTHWISE CONVOLUTION
+
+The weights of a $k \times k$ depthwise convolution kernel form a $C \times k ^ { 2 }$ matrix. DCD can be generalized to such matrices by replacing in Eq. 6 the matrix $Q$ (which squeezes the number of channels) with a matrix $\pmb { R }$ (which squeezes the number of kernel elements)
+
+$$
+\begin{array} { r } { \pmb { W } ( \pmb { x } ) = \pmb { \Lambda } ( \pmb { x } ) \pmb { W } _ { 0 } + \pmb { P } \pmb { \Phi } ( \pmb { x } ) \pmb { R } ^ { T } , } \end{array}
+$$
+
+where $W ( { \pmb x } )$ and $W _ { 0 }$ are $C \times k ^ { 2 }$ matrices, $\Lambda ( x )$ is a diagonal $C \times C$ matrix that implements channel-wise attention, $\pmb { R }$ is a $k ^ { 2 } \times L _ { k }$ matrix that reduces the number of kernel elements from $k ^ { 2 }$ to $L _ { k }$ , $\Phi ( x )$ is a $L _ { k } \times L _ { k }$ matrix that performs dynamic fusion along $L _ { k }$ latent kernel elements and $_ { r }$ is a $C \times L _ { k }$ weight matrix for depthwise convolution over $L _ { k }$ kernel elements. The default value of $L _ { k }$ is $\lfloor k ^ { 2 } / 2 \rfloor$ . Since depthwise convolution is channel separable, $\Phi ( x )$ does not fuse channels, fusing instead $L _ { k }$ latent kernel elements.
+
+![](images/8df9ba9a9296643849764ddae81071ae4a777206b079a6f48817156020193453.jpg)  
+Figure 4: The dynamic convolution decomposition for $k \times k$ convolution.
+
+# 4.3 DCD OF $k \times k$ CONVOLUTION
+
+Joint fusion of channels and kernel elements: A $k \times k$ convolution kernel forms a $C \times C \times k ^ { 2 }$ tensor. DCD can be generalized to such tensors by extending Eq. 6 into a tensor form (see Figure 4)
+
+$$
+W ( { \pmb x } ) = W _ { 0 } \times _ { 2 } \Lambda ( { \pmb x } ) + \Phi ( { \pmb x } ) \times _ { 1 } { \pmb Q } \times _ { 2 } { \pmb P } \times _ { 3 } { \pmb R } ,
+$$
+
+where $\times _ { n }$ refers to $n$ -mode multiplication (Lathauwer et al., 2000), $W _ { 0 }$ is a $C \times C \times k ^ { 2 }$ tensor, $\Lambda ( x )$ is a diagonal $C \times C$ matrix that implements channel-wise attention, $Q$ is a $C \times L$ matrix that reduces the number of input channels from $C$ to $L , R$ is a $k ^ { 2 } \times L _ { k }$ matrix that reduces the number of kernel elements from $k ^ { 2 }$ to $L _ { k }$ , $\Phi ( x )$ is a $L \times L \times L _ { k }$ tensor that performs joint fusion of $L$ channels over $L _ { k }$ latent kernel elements, and $_ { r }$ is a $C \times L$ matrix that expands the number of channels from $L$ to $C$ . The numbers of latent channels $L$ and latent kernel elements $L _ { k }$ are constrained by $L _ { k } < k ^ { 2 }$ and $L ^ { 2 } L _ { k } \le C$ . Their default values are set empirically to $L _ { k } = \lfloor k ^ { 2 } / 2 \rfloor$ , $\begin{array} { r } { L = \lfloor \frac { C / L _ { k } ^ { \top } } { 2 ^ { \lfloor l o g _ { 2 } \sqrt { C / L _ { k } } \rfloor } } \rfloor } \end{array}$
+
+Channel fusion alone: We found that the fusion of channels $\Phi ( { \pmb x } ) \times _ { 1 } Q$ is more important than the fusion of kernel elements $\Phi ( { \pmb x } ) \times _ { 3 } R$ . Therefore, we reduce $L _ { k }$ to 1 and increase $L$ accordingly. $\pmb { R }$ is simplified into a one-hot vector $[ 0 , \ldots , 0 , 1 , 0 , \ldots , 0 ] ^ { T }$ , where the ‘1’ is located at the center (assuming that $k$ is an odd number). As illustrated in Figure 4-(b), the tensor of dynamic residual $\Phi ( { \pmb x } ) \times _ { 1 } { \pmb Q } \times _ { 2 } { \pmb P } \times _ { 3 } { \pmb R }$ only has one non-zero slice, which is equivalent to a $1 \times 1$ convolution. Therefore, the DCD of a $k \times k$ convolution is essentially adding a $1 \times 1$ dynamic residual to a static $k \times k$ kernel.
+
+# 5 EXPERIMENTS
+
+In this section, we present the results of DCD on ImageNet classification (Deng et al., 2009). ImageNet has 1,000 classes with 1,281,167 training and 50, 000 validation images. We also report ablation studies on different components of the approach.
+
+All experiments are based on two network architectures: ResNet (He et al., 2016) and MobileNetV2 (Sandler et al., 2018). DCD is implemented on all convolutional layers of ResNet and all $1 \times 1$ convolutional layers of MobileNetV2. The reduction ratio $r$ is set to 16 for ResNet and MobileNetV2 $\times 1 . 0$ , and to 8 for smaller models (MobileNetV2 $\times 0 . 5$ and $\times 0 . 3 5 )$ ). All models are trained by SGD with momentum 0.9. The batch size is 256 and remaining training parameters are as follows.
+
+ResNet: The learning rate starts at 0.1 and is divided by 10 every 30 epochs. The model is trained with 100 epochs. Dropout (Srivastava et al., 2014) 0.1 is used only for ResNet-50.
+
+MobileNetV2: The initial learning rate is 0.05 and decays to 0 in 300 epochs, according to a cosine function. Weight decay of 2e-5 and a dropout rate of 0.1 are also used. For MobileNetV2 $\times 1 . 0$ Mixup (Zhang et al., 2018a) and label smoothing are further added to avoid overfitting.
+
+<table><tr><td>Model</td><td>Params MAdds</td><td>Top-1</td></tr><tr><td>Wo (static)</td><td>2.0M 97.0M</td><td>65.4</td></tr><tr><td>AWo</td><td>2.4M 97.4M</td><td>68.2</td></tr><tr><td>W+PΦQT</td><td>2.7M 104.4M</td><td>69.2</td></tr><tr><td>AW+PΦQT</td><td>2.9M 104.6M</td><td>69.8</td></tr></table>
+
+Table 1: Different formulations of dynamic convolution decomposition on ImageNet classification.   
+
+<table><tr><td>Model</td><td>Params</td><td>MAdds</td><td>Top-1</td></tr><tr><td>Wo (static)</td><td>11.1M</td><td>1.81G</td><td>70.4</td></tr><tr><td>AWo</td><td>11.7M</td><td>1.81G</td><td>71.5</td></tr><tr><td>Wo+PΦQT</td><td>13.6M</td><td>1.83G</td><td>72.8</td></tr><tr><td>AW+PΦQT</td><td>14.0M</td><td>1.83G</td><td>73.1</td></tr></table>
+
+# (a) MobileNet ${ \bf V } 2 \times 0 . 5$
+
+# (b) ResNet-18
+
+# 5.1 INSPECTING DIFFERENT DCD FORMULATIONS
+
+Table 1 summarizes the influence of different components (e.g. dynamic channel fusion $\Phi ( { \pmb x } )$ , dynamic channel-wise attention $\pmb { \Lambda } ( \pmb { x } ) )$ ) of DCD on MobileNet ${ \bf V } 2 \times 0 . 5$ and ResNet-18 performance. The table shows that both dynamic components, $\pmb { \Lambda } ( \pmb { x } )$ and $\Phi ( { \pmb x } )$ of Eq. 6. enhance accuracy substantially $( + 2 . 8 \%$ and $+ 3 . 8 \%$ for MobileNetV2 $\times 0 . 5$ , $+ 1 . 1 \%$ and $+ 2 . 4 \%$ for ResNet-18), when compared to the static baseline. Using dynamic channel fusion only $( W _ { 0 } + P \Phi Q ^ { T } )$ has slightly more parameters, FLOPs, and accuracy than using dynamic channel-wise attention only $( \Lambda W _ { 0 } )$ . The combination of the two mechanisms provides additional improvement.
+
+# 5.2 ABLATIONS
+
+A number of ablations were performed on MobileNet ${ \bf V } 2 { \bf \Psi } \times 0 . 5$ to analyze DCD performance in terms of two questions.
+
+1. How does the dimension $( L )$ of the latent space affect performance?
+
+2. How do three DCD variants perform?
+
+The default configuration is the general form of DCD (Eq. 6) with a full size dynamic residual $B = 1$ ) for all pointwise convolution layers. The default latent space dimension is $\begin{array} { r } { \dot { L } = \lfloor \frac { C } { 2 ^ { \lfloor l o g _ { 2 } \sqrt { C } \rfloor } } \rfloor } \end{array}$
+
+Latent Space Dimension $L$ : The dynamic channel fusion matrix $\Phi ( { \pmb x } )$ has size $L \times L$ . Thus, $L$ controls both the representation and the parameter complexity of DCD. We adjust it by applying different multipliers to the default value of $L$ . Table 2 shows the results of MobileNetV2 $\times 0 . 5$ for four multiplier values ranging from $\times 1 . 0$ to $\times 0 . 2 5$ . As $L$ decreases, fewer parameters are required and the performance degrades slowly. Even with a very low dimensional latent space $( L \times 0 . 2 5 )$ , DCD still outperforms the static baseline by $3 . 3 \%$ top-1 accuracy.
+
+Table 2: Dimension of the latent space $L$ evaluated on ImageNet classification (MobileNetV2 $\times 0 . 5$ is used).   
+
+<table><tr><td>Model</td><td>L</td><td>Params</td><td>MAdds</td><td>Top-1</td></tr><tr><td>static</td><td>-</td><td>2.0M</td><td>97.0M</td><td>65.4</td></tr><tr><td rowspan="4">DCD</td><td>×0.25</td><td>2.4M</td><td>99.8M</td><td>68.7</td></tr><tr><td>×0.50</td><td>2.5M</td><td>101.3M</td><td>69.0</td></tr><tr><td>×0.75</td><td>2.6M</td><td>102.9M</td><td>69.6</td></tr><tr><td>×1.0</td><td>2.9M</td><td>104.6M</td><td>69.8</td></tr></table>
+
+# Number of Diagonal Blocks $B$ in the Dynamic
+
+Residual: Table 3-(a) shows classification results for four values of $B$ . The dynamic residual is a full matrix when $B = 1$ , while only $\frac { 1 } { 8 }$ of its entries are non-zero for $B = 8$ . Accuracy degrades slowly as the dynamic residual becomes sparser (increasing $B$ ). The largest performance drop happens when $B$ is changed from 1 to 2, as half of the weight matrix $W ( { \pmb x } )$ becomes static. However, performance is still significantly better than that of the static baseline. The fact that even the sparsest $B = 8$ outperforms the static baseline by $2 . 9 \%$ (from $6 5 . 4 \%$ to $6 8 . 3 \%$ ) demonstrates the representation power of the dynamic residual. In all cases, dynamic channel-wise attention $\pmb { \Lambda } ( \pmb { x } )$ enables additional performance gains.
+
+DCD at Different Layers: Table 3-(b) shows the results of implementing DCD for three different types of layers (a) DW: depthwise convolution (Eq. 8), (b) PW: pointwise convolution (Eq. 6), and (c) CLS: fully connected classifier, which is a special case of pointwise convolution (the input resolution is $1 \times 1$ ). Using DCD in any type of layer improves on the performance of the static baseline $( + 2 . 9 \%$ for depthwise convolution, $+ 4 . 4 \%$ for pointwise convolution, and $+ 1 . 2 \%$ for classifier). Combining DCD for both pointwise convolution and classifier achieves the best performance
+
+Table 3: Extensions of dynamic convolution decompostion (DCD) evaluated on ImageNet classification (MobileNetV2 $\times 0 . 5$ is used).   
+
+<table><tr><td>Network</td><td>B</td><td>Params</td><td>MAdds</td><td>Top-1</td></tr><tr><td>Wo (static)</td><td>-</td><td>2.0M</td><td>97.0M 65.4</td><td></td></tr><tr><td rowspan="4">Wo + PΦQT</td><td>1</td><td>2.7M</td><td>104.4M</td><td>69.2</td></tr><tr><td>2</td><td>2.6M</td><td>101.0M</td><td>68.5</td></tr><tr><td>4</td><td>2.5M</td><td>99.1M</td><td>68.4</td></tr><tr><td>8</td><td>2.5M</td><td>98.5M</td><td>68.3</td></tr><tr><td rowspan="4">AWo+PΦQT</td><td>1</td><td>2.9M</td><td>104.6M</td><td>69.8</td></tr><tr><td>2</td><td>2.8M</td><td>101.3M</td><td>68.9</td></tr><tr><td>4</td><td>2.7M</td><td>99.4M</td><td>68.8</td></tr><tr><td>8</td><td>2.7M</td><td>98.8M</td><td>68.5</td></tr></table>
+
+$\mathbf { ( b ) }$ DCD at different layers. DW, PW, and CLS indicate depthwise convolution, pointwise convolution and classifier respectively.
+
+# (a) Number of diagonal blocks $B$ in the dynamic residual.
+
+<table><tr><td>DW</td><td>PW</td><td>CLS</td><td>Params MAdds</td><td>Top-1</td></tr><tr><td></td><td></td><td>2.0M</td><td>97.0M</td><td>65.4</td></tr><tr><td>√</td><td></td><td>2.4M</td><td>97.5M</td><td>68.3</td></tr><tr><td></td><td>√</td><td></td><td>2.9M 104.6M</td><td>69.8</td></tr><tr><td></td><td></td><td>√</td><td>2.2M 97.2M</td><td>66.6</td></tr><tr><td>√</td><td></td><td>√</td><td>2.6M 97.7M</td><td>69.0</td></tr><tr><td>√</td><td>√</td><td></td><td>3.3M 105.1M</td><td>69.6</td></tr><tr><td></td><td>√</td><td>√</td><td>3.1M 104.8M</td><td>70.2</td></tr><tr><td>√</td><td>√</td><td>√</td><td>3.5M 105.3M</td><td>70.0</td></tr></table>
+
+Table 4: Comparing DCD with the vanilla dynamic convolution CondConv (Yang et al., 2019) and DY-Conv (Chen et al., 2020c). ✶indicates the dynamic model with the fewest parameters (static model is not included). CondConv contains $K = 8$ kernels and DY-Conv contains $K = 4$ kernels.   
+
+<table><tr><td>Width</td><td>Model</td><td>Params</td><td>MAdds</td><td>Top-1</td></tr><tr><td>×1.0</td><td>static DY-Conv CondConv DCD (ours)</td><td>3.5M 300.0M 11.1M 312.9M 27.5M 329.0M *5.5M 326.0M</td><td></td><td>72.0 75.2 74.6 75.2</td></tr><tr><td>×0.5</td><td>static DY-Conv CondConv DCD (ours)</td><td>2.0M 4.0M 15.5M *3.1M</td><td>97.0M 101.4M 113.0M 104.8M</td><td>65.4 69.9 68.4 70.2</td></tr><tr><td>×0.35</td><td>static DY-Conv DCD (ours)</td><td>1.7M 2.8M *2.3M</td><td>59.2M 62.0M 63.1M</td><td>60.3 65.9 66.6</td></tr></table>
+
+<table><tr><td>Depth</td><td>Model</td><td>Params</td><td>MAdds</td><td>Top-1</td></tr><tr><td rowspan="2">ResNet-50</td><td>static</td><td>23.5M</td><td>3.8G</td><td>76.2</td></tr><tr><td>DCD (ours)</td><td>30.7M</td><td>3.9G</td><td>77.9</td></tr><tr><td rowspan="3">ResNet-18</td><td>static</td><td>11.1M</td><td>1.81G</td><td>70.4</td></tr><tr><td>DY-Conv</td><td>42.7M</td><td>1.85G</td><td>72.7</td></tr><tr><td>DCD (ours)</td><td>*14.0M</td><td>1.83G</td><td>73.1</td></tr><tr><td rowspan="3">ResNet-10</td><td>static</td><td>5.2M</td><td>0.89G</td><td>63.5</td></tr><tr><td>DY-Conv</td><td>18.6M</td><td>0.91G</td><td>67.7</td></tr><tr><td>DCD (ours)</td><td>*6.5M</td><td>0.90G</td><td>68.8</td></tr></table>
+
+# (a) MobileNetV2.
+
+(b) ResNet.
+
+$( + 4 . 8 \% )$ . We notice a performance drop (from $7 0 . 2 \%$ to $7 0 . 0 \%$ ) when using DCD in all three types of layers. We believe this is due to overfitting, as it has higher training accuracy.
+
+Extension to $3 \times 3$ Convolution: We use ResNet-18, which stacks 16 layers of $3 \times 3$ convolution, to study the $3 \times 3$ extension of DCD (see Section 4.3). Compared to the static baseline $7 0 . 4 \%$ top-1 accuracy), DCD with joint fusion of channels and kernel elements (Eq. 9) improves top-1 accuracy $( 7 1 . 3 \% )$ by $0 . 9 \%$ . The top-1 accuracy is further improved by $1 . 8 \%$ $( 7 3 . 1 \% )$ , when using DCD with channel fusion alone, which transforms the dynamic residual as a $1 \times 1$ convolution matrix (see Figure 4-(b)). This demonstrates that dynamic fusion is more effective across channels than across kernel elements.
+
+Summary: Based on the ablations above, DCD should be implemented with both dynamic channel fusion $\Phi$ and dynamic channel-wise attention $\pmb { \Lambda }$ , the default latent space dimension $L$ , and a full size residual $B = 1$ . DCD is recommended for pointwise convolution and classifier layers in MobileNetV2. For $3 \times 3$ convolutions in ResNet, DCD should be implemented with channel fusion alone. The model can be made more compact, for a slight performance drop, by (a) removing dynamic channel-wise attention $\pmb { \Lambda }$ , (b) reducing the latent space dimension $L$ , (c) using a sparser dynamic residual (increasing $B$ ), and (d) implementing DCD in depthwise convolution alone.
+
+# 5.3 MAIN RESULTS
+
+DCD was compared to the vanilla dynamic convolution (Yang et al., 2019; Chen et al., 2020c) for MobileNetV2 and ResNet, using the settings recommended above, with the results of
+
+Table $4 ^ { 1 }$ . DCD significantly reduces the number of parameters while improving the performance of both network architectures. For MobileNetV2 $\times 1 . 0$ , DCD only requires $50 \%$ of the parameters of (Chen et al., 2020c) and $2 5 \%$ of the parameters of (Yang et al., 2019). For ResNet-18, it only requires $33 \%$ of the parameters of (Chen et al., 2020c), while achieving a $0 . 4 \%$ gain in top-1 accuracy. Although DCD requires slightly more MAdds than (Chen et al., 2020c), the increment is negligible. These results demonstate that DCD is more compact and effective.
+
+Figure 5 compares DCD to DY-Conv (Chen et al., 2020c) in terms of training convergence. DY-Conv uses a large temperature in its softmax to alleviate the joint optimization difficulty and make training more efficient. Without any additional parameter tuning, DCD converges even faster than DY-Conv with a large temperature and achieves higher accuracy.
+
+![](images/99e5e2fe3eb00d74cf9d49d1f2c23341d4a0d8e6e63a8b648648b65579c58e94.jpg)  
+Figure 5: The comparison of training and validation error between DCD and DY-Conv on MobileNetV2 $\times 0 . 5$ . $\tau$ is the temperature in softmax. Best viewed in color.
+
+# 5.4 ANALYSIS OF DYNAMIC CHANNEL FUSION
+
+To validate the dynamic property, $\Phi ( { \pmb x } )$ should have different values over different images. We measure this by averaging the variance of each entry $\begin{array} { r } { \sigma _ { \Phi } = \sum _ { i , j } \sigma _ { i , j } / L ^ { 2 } } \end{array}$ where $\sigma _ { i , j }$ is the variance of $\phi _ { i , j } ( \pmb { x } )$ , over all validation images. To compare $\sigma _ { \Phi }$ across layers, we normalize it by the variance of the corresponding input feature map. Figure 6 shows the normalized variance $\sigma _ { \Phi }$ across layers in MobileNetV2. Clearly, the dynamic coefficients vary more in the higher layers. We believe this is because the higher layers encode more context information, providing more clues to adapt convolution weights.
+
+# 5.5 INFERENCE TIME
+
+![](images/aa040ac66e6659fc2e58dee51bb5627be93880e67fb707a48e441a14afb395e8.jpg)  
+Figure 6: Normalized variance of dynamic coefficients $\sigma _ { \Phi }$ across layers in MobileNetV2 $\times 0 . 5$ and $\times 1 . 0$ .
+
+We use a single-threaded core AMD EPYC CPU 7551P $( 2 . 0 \mathrm { G H z } )$ to measure running time (in milliseconds) on MobileNetV2 $\times 0 . 5$ and $\times 1 . 0$ . Running time is calculated by averaging the inference time of 5,000 images with batch size 1. Both static baseline and DCD are implemented in PyTorch. Compared with the static baseline, DCD consumes about $8 \%$ more MAdds (97.0M vs 104.8M) and $14 \%$ more running time (91ms vs $\mathrm { 1 0 4 m s ) }$ for Mobile ${ \mathrm { N e t V } } 2 \times 0 . 5$ . For MobileNetV2 $\times 1 . 0$ , DCD consumes $9 \%$ more MAdds (300.0M vs 326.0M) and $12 \%$ more running time (146ms vs $1 6 3 \mathrm { m s }$ ). The overhead is higher in running time than MAdds. We believe this is because the optimizations of global average pooling and fully connected layers are not as efficient as convolution. This small penalty in inference time is justified by the DCD gains of $4 . 8 \%$ and $3 . 2 \%$ top-1 accuracy over MobileNetV2 $\times 0 . 5$ and $\times 1 . 0$ respectively.
+
+# 6 CONCLUSION
+
+In this paper, we have revisited dynamic convolution via matrix decomposition and demonstrated the limitations of dynamic attention over channel groups: it multiplies the number of parameters by $K$ and increases the difficulty of joint optimization. We proposed a dynamic convolution decomposition to address these issues. This applies dynamic channel fusion to significantly reduce the dimensionality of the latent space, resulting in a more compact model that is easier to learn with often improved accuracy. We hope that our work provides a deeper understanding of the gains recently observed for dynamic convolution.
+
+# REFERENCES
+
+Han Cai, Chuang Gan, and Song Han. Once for all: Train one network and specialize it for efficient deployment. ArXiv, abs/1908.09791, 2019.
+
+Hanting Chen, Yunhe Wang, Chunjing Xu, Boxin Shi, Chao Xu, Qi Tian, and Chang Xu. Addernet: Do we really need multiplications in deep learning? In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020a.
+
+Jyun-Ruei Chen, Xijun Wang, Zichao Guo, X. Zhang, and J. Sun. Dynamic region-aware convolution. ArXiv, abs/2003.12243, 2020b.
+
+Yinpeng Chen, Xiyang Dai, Mengchen Liu, Dongdong Chen, Lu Yuan, and Zicheng Liu. Dynamic convolution: Attention over convolution kernels. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020c.
+
+Yinpeng Chen, Xiyang Dai, Mengchen Liu, Dongdong Chen, Lu Yuan, and Zicheng Liu. Dynamic relu. arXiv preprint arXiv:2003.10027, abs/2003.10027, 2020d.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009.
+
+Emily L Denton, Wojciech Zaremba, Joan Bruna, Yann LeCun, and Rob Fergus. Exploiting linear structure within convolutional networks for efficient evaluation. In Advances in neural information processing systems, pp. 1269–1277, 2014.
+
+David Ha, Andrew M. Dai, and Quoc V. Le. Hypernetworks. ICLR, 2017.
+
+Kai Han, Yunhe Wang, Qi Tian, Jianyuan Guo, Chunjing Xu, and Chang Xu. Ghostnet: More features from cheap operations. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Andrew Howard, Mark Sandler, Grace Chu, Liang-Chieh Chen, Bo Chen, Mingxing Tan, Weijun Wang, Yukun Zhu, Ruoming Pang, Vijay Vasudevan, Quoc V. Le, and Hartwig Adam. Searching for mobilenetv3. CoRR, abs/1905.02244, 2019. URL http://arxiv.org/abs/1905. 02244.
+
+Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017.
+
+Jie Hu, Li Shen, and Gang Sun. Squeeze-and-excitation networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018.
+
+Kevin Jarrett, Koray Kavukcuoglu, Marc’Aurelio Ranzato, and Yann LeCun. What is the best multistage architecture for object recognition? In The IEEE International Conference on Computer Vision (ICCV), 2009.
+
+Yong-Deok Kim, Eunhyeok Park, Sungjoo Yoo, Taelim Choi, Lu Yang, and Dongjun Shin. Compression of deep convolutional neural networks for fast and low power mobile applications. arXiv preprint arXiv:1511.06530, 2015.
+
+Jean Kossaifi, Antoine Toisoul, Adrian Bulat, Yannis Panagakis, Timothy M Hospedales, and Maja Pantic. Factorized higher-order cnns with an application to spatio-temporal emotion estimation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 6060–6069, 2020.
+
+L. D. Lathauwer, B. D. Moor, and J. Vandewalle. A multilinear singular value decomposition. In SIAM J. Matrix Anal. Appl, 2000.
+
+Vadim Lebedev, Yaroslav Ganin, Maksim Rakhuba, Ivan Oseledets, and Victor Lempitsky. Speeding-up convolutional neural networks using fine-tuned cp-decomposition. arXiv preprint arXiv:1412.6553, 2014.
+
+Xiang Li, Wenhai Wang, Xiaolin Hu, and Jian Yang. Selective kernel networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.
+
+Ningning Ma, Xiangyu Zhang, Hai-Tao Zheng, and Jian Sun. Shufflenet v2: Practical guidelines for efficient cnn architecture design. In The European Conference on Computer Vision (ECCV), September 2018.
+
+Ningning Ma, X. Zhang, J. Huang, and J. Sun. Weightnet: Revisiting the design space of weight networks. volume abs/2007.11823, 2020.
+
+Vinod Nair and Geoffrey E. Hinton. Rectified linear units improve restricted boltzmann machines. In ICML, 2010.
+
+Anh-Huy Phan, Konstantin Sobolev, Konstantin Sozykin, Dmitry Ermilov, Julia Gusak, Petr Tichavsky, Valeriy Glukhov, Ivan Oseledets, and Andrzej Cichocki. Stable low-rank tensor decomposition for compression of convolutional neural network. arXiv preprint arXiv:2008.05441, 2020.
+
+Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4510–4520, 2018.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(56):1929–1958, 2014. URL http://jmlr.org/papers/v15/ srivastava14a.html.
+
+Zhuo Su, Linpu Fang, Wen xiong Kang, D. Hu, M. Pietikainen, and Li Liu. Dynamic group convo- ¨ lution for accelerating convolutional neural networks. In ECCV, August 2020.
+
+Mingxing Tan and Quoc Le. Efficientnet: Rethinking model scaling for convolutional neural networks. In ICML, pp. 6105–6114, Long Beach, California, USA, 09–15 Jun 2019a.
+
+Mingxing Tan and Quoc V. Le. Mixconv: Mixed depthwise convolutional kernels. In 30th British Machine Vision Conference 2019, 2019b.
+
+Mingxing Tan, Ruoming Pang, and Quoc V. Le. Efficientdet: Scalable and efficient object detection. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.
+
+Zhi Tian, Chunhua Shen, and Hao Chen. Conditional convolutions for instance segmentation. In ECCV, August 2020.
+
+Brandon Yang, Gabriel Bender, Quoc V. Le, and Jiquan Ngiam. Condconv: Conditionally parameterized convolutions for efficient inference. In NeurIPS, 2019.
+
+Jiahui Yu, Linjie Yang, Ning Xu, Jianchao Yang, and Thomas Huang. Slimmable neural networks. In International Conference on Learning Representations, 2019. URL https://openreview. net/forum?id ${ . } = { }$ H1gMCsAqY7.
+
+Hongyi Zhang, Moustapha Cisse, Yann N. Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In International Conference on Learning Representations, 2018a. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ r1Ddp1-Rb.
+
+Xiangyu Zhang, Xinyu Zhou, Mengxiao Lin, and Jian Sun. Shufflenet: An extremely efficient convolutional neural network for mobile devices. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018b.
+
+Daquan Zhou, Qi-Bin Hou, Y. Chen, Jiashi Feng, and S. Yan. Rethinking bottleneck structure for efficient mobile network design. In ECCV, August 2020.

parse/train/YwpZmcAehZ/YwpZmcAehZ_content_list.json

@@ -0,0 +1,1663 @@
+[
+    {
+        "type": "text",
+        "text": "REVISITING DYNAMIC CONVOLUTION VIA MATRIX DECOMPOSITION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yunsheng $\\mathbf { L i ^ { 1 } }$ , Yinpeng Chen2, Xiyang Dai2, Mengchen Liu2, Dongdong Chen2, Ye $\\mathbf { Y } \\mathbf { u } ^ { 2 }$ , Lu Yuan2, Zicheng $\\mathbf { L i u } ^ { 2 }$ , Mei Chen2, Nuno Vasconcelos1 ",
+        "bbox": [
+            184,
+            169,
+            789,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Department of Electrical and Computer Engineering, University of California San Diego 2 Microsoft yul554@ucsd.edu, {yiche,xidai,mengcliu,dochen}@microsoft.com {Yu.Ye,luyuan,zliu,Mei.Chen}@microsoft.com, nvasconcelos@ucsd.edu ",
+        "bbox": [
+            184,
+            202,
+            818,
+            257
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            292,
+            544,
+            308
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent research in dynamic convolution shows substantial performance boost for efficient CNNs, due to the adaptive aggregation of $K$ static convolution kernels. It has two limitations: (a) it increases the number of convolutional weights by $K$ - times, and (b) the joint optimization of dynamic attention and static convolution kernels is challenging. In this paper, we revisit it from a new perspective of matrix decomposition and reveal the key issue is that dynamic convolution applies dynamic attention over channel groups after projecting into a higher dimensional latent space. To address this issue, we propose dynamic channel fusion to replace dynamic attention over channel groups. Dynamic channel fusion not only enables significant dimension reduction of the latent space, but also mitigates the joint optimization difficulty. As a result, our method is easier to train and requires significantly fewer parameters without sacrificing accuracy. Source code is at https://github.com/liyunsheng13/dcd. ",
+        "bbox": [
+            232,
+            324,
+            764,
+            505
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            532,
+            336,
+            547
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Dynamic convolution (Yang et al., 2019; Chen et al., 2020c) has recently become popular for the implementation of light-weight networks (Howard et al., 2017; Zhang et al., 2018b). Its ability to achieve significant performance gains with negligible computational cost has motivated its adoption for multiple vision tasks (Su et al., 2020; Chen et al., 2020b; Ma et al., 2020; Tian et al., 2020). The basic idea is to aggregate multiple convolution kernels dynamically, according to an input dependent attention mechanism, into a convolution weight matrix ",
+        "bbox": [
+            173,
+            563,
+            825,
+            647
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ff7a32be9efad8ff0aa379bb719338333d336add3ab5ec196be7a539f6a28cfd.jpg",
+        "text": "$$\n{ W } ( { \\pmb x } ) = \\sum _ { k = 1 } ^ { K } { \\pi } _ { k } ( { \\pmb x } ) { W } _ { k } \\quad \\mathrm { s . t . } \\quad 0 \\leq { \\pi } _ { k } ( { \\pmb x } ) \\leq 1 , \\sum _ { k = 1 } ^ { K } { \\pi } _ { k } ( { \\pmb x } ) = 1 ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            654,
+            707,
+            699
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "where $K$ convolution kernels $\\{ W _ { k } \\}$ are aggregated linearly with attention scores $\\{ \\pi _ { k } ( \\pmb x ) \\}$ ",
+        "bbox": [
+            171,
+            705,
+            769,
+            720
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Dynamic convolution has two main limitations: (a) lack of compactness, due to the use of $K$ kernels, and (b) a challenging joint optimization of attention scores $\\{ \\pi _ { k } ( \\pmb x ) \\}$ and static kernels $\\{ W _ { k } \\}$ . Yang et al. (2019) proposed the use of a sigmoid layer to generate attention scores $\\{ \\pi _ { k } ( \\pmb x ) \\}$ , leading to a significantly large space for the convolution kernel $W ( { \\pmb x } )$ that makes the learning of attention scores $\\{ \\pi _ { k } ( \\pmb { x } ) \\}$ difficult. Chen et al. (2020c) replaced the sigmoid layer with a softmax function to compress the kernel space. However, small attention scores $\\pi _ { k }$ output by the softmax make the corresponding kernels $W _ { k }$ difficult to learn, especially in early training epochs, slowing training convergence. To mitigate these limitations, these two methods require additional constraints. For instance, Chen et al. (2020c) uses a large temperature in the softmax function to encourage nearuniform attention. ",
+        "bbox": [
+            173,
+            726,
+            825,
+            866
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we revisit the two limitations via matrix decomposition. To expose the limitations, we reformulate dynamic convolution in terms of a set of residuals, re-defining the static kernels as ",
+        "bbox": [
+            173,
+            872,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ad3691340613c59bb9d7d1987ff6ca51bd6a73ff6daca2552307017e393ef1b1.jpg",
+        "text": "$$\nW _ { k } = W _ { 0 } + \\Delta W _ { k } , \\quad k \\in \\{ 1 , \\dots , K \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            907,
+            632,
+            925
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/37bcad854ab5107fa0603b86e9d44ef280f13e0cb573e308edbfa0cc7ad8f34e.jpg",
+        "image_caption": [
+            "Figure 1: Dynamic convolution via matrix decomposition. Left: Reformulating the vanilla dynamic convolution by matrix decomposition (see Eq. 3). It applies dynamic attention $\\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\pi \\mathbf { \\Pi } \\mathbf { \\Pi } \\left( \\pmb { x } \\right)$ over channel groups in a high dimensional space $( S V ^ { \\bar { T } } { \\pmb x } ~ \\in ~ \\mathbb { R } ^ { \\pmb { \\dot { K } } \\pmb { \\dot { C } } } ,$ ). Right: proposed dynamic convolution decomposition, which applies dynamic channel fusion $\\Phi ( { \\pmb x } )$ in a low dimensional space ${ \\bf \\nabla } Q ^ { T } { \\bf x } \\in$ $\\mathbb { R } ^ { L }$ , $L \\ll C )$ , resulting in a more compact model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            102,
+            799,
+            198
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { { W _ { 0 } } = \\frac { 1 } { K } \\sum _ { k = 1 } ^ { K } W _ { k } } \\end{array}$ is the average kernel and $\\Delta W _ { k } = W _ { k } - W _ { 0 }$ a residual weight matrix. Further decomposing the latter with an SVD, $\\Delta W _ { k } = U _ { k } S _ { k } V _ { k } ^ { T }$ , leads to ",
+        "bbox": [
+            176,
+            294,
+            825,
+            328
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f7bc3b90025bffe4b2a66adac3190ee4bd147bd5b0889e9432169e3c287b7b77.jpg",
+        "text": "$$\n\\boldsymbol { W } ( \\boldsymbol { x } ) = \\sum _ { k = 1 } ^ { K } \\pi _ { k } ( \\boldsymbol { x } ) \\boldsymbol { W } _ { 0 } + \\sum _ { k = 1 } ^ { K } \\pi _ { k } ( \\boldsymbol { x } ) \\boldsymbol { U } _ { k } \\boldsymbol { S } _ { k } \\boldsymbol { V } _ { k } ^ { T } = \\boldsymbol { W } _ { 0 } + \\boldsymbol { U } \\boldsymbol { \\Pi } ( \\boldsymbol { x } ) \\boldsymbol { S } \\boldsymbol { V } ^ { T } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            335,
+            736,
+            380
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $U = [ U _ { 1 } , \\dots , U _ { K } ]$ , ${ \\pmb S } = d i a g ( { \\pmb S } _ { 1 } , \\ldots , { \\pmb S } _ { K } )$ , $V = [ V _ { 1 } , \\dots , V _ { K } ]$ , and $\\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\pi \\mathbf { \\Pi } \\mathbf { \\Pi } \\left( \\pmb { x } \\right)$ stacks attention scores diagonally as $\\Pi ( { \\pmb x } ) = d i a g ( \\pi _ { 1 } ( { \\pmb x } ) { \\pmb I } , \\ldots , \\pi _ { K } ( { \\pmb x } ) { \\pmb I } )$ , where $\\pmb { I }$ is an identity matrix. This decomposition, illustrated in Figure $^ { 1 , }$ shows that the dynamic behavior of $W ( { \\pmb x } )$ is implemented by the dynamic residual $U \\mathbf { I I } ( \\mathbf { \\bar { x } } ) S V ^ { T }$ , which projects the input $_ { \\textbf { \\em x } }$ to a higher dimensional space $\\Dot { S V } ^ { T } x$ (from $C$ to $K C$ channels), applies dynamic attention $\\Pi ( x )$ over channel groups, and reduces the dimension back to $C$ channels, through multiplication by $U$ . This suggests that the limitations of vanilla dynamic convolution are due to the use of attention over channel groups, which induces a high dimensional latent space, leading to small attention values that may suppress the learning of the corresponding channels. ",
+        "bbox": [
+            174,
+            386,
+            825,
+            513
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To address this issue, we propose a dynamic convolution decomposition (DCD), that replaces dynamic attention over channel groups with dynamic channel fusion. The latter is based on a full dynamic matrix $\\Phi ( { \\pmb x } )$ , of which each element $\\phi _ { i , j } ( \\pmb { x } )$ is a function of input $_ { \\textbf { \\em x } }$ . As shown in Figure 1-(right), the dynamic residual is implemented as the product $P \\Phi ( { \\pmb x } ) Q ^ { T }$ of $\\Phi ( { \\pmb x } )$ and two static matrices $P , Q$ , such that $Q$ compresses the input into a low dimensional latent space, $\\Phi ( { \\pmb x } )$ dynamically fuses the channels in this space, and $_ { P }$ expands the number of channels to the output space. The key innovation is that dynamic channel fusion with $\\Phi ( { \\pmb x } )$ enables a significant dimensionality reduction of the latent space $Q ^ { T } { \\pmb x } \\in \\mathbb { R } ^ { L }$ , $L \\ll C$ ). Hence the number of parameters in $P , Q$ is significantly reduced, when compared to $U , V$ of Eq. 3, resulting in a more compact model. Dynamic channel fusion also mitigates the joint optimization challenge of vanilla dynamic convolution, as each column of $P , Q$ is associated with multiple dynamic coefficients of $\\Phi ( { \\pmb x } )$ . Hence, a few dynamic coefficients of small value are not sufficient to suppress the learning of static matrices $P , Q$ . Experimental results show that DCD both significantly reduces the number of parameters and achieves higher accuracy than vanilla dynamic convolution, without requiring the additional constraints of (Yang et al., 2019; Chen et al., 2020c). ",
+        "bbox": [
+            174,
+            520,
+            825,
+            729
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            751,
+            344,
+            767
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Efficient CNNs: MobileNet (Howard et al., 2017; Sandler et al., 2018; Howard et al., 2019) decomposes $k \\times k$ convolution into a depthwise and a pointwise convolution. ShuffleNet (Zhang et al., 2018b; Ma et al., 2018) uses group convolution and channel shuffle to further simplify pointwise convolution. Further improvements of these architectures have been investigated recently. EfficientNet (Tan & Le, 2019a; Tan et al., 2020) finds a proper relationship between input resolution and width/depth of the network. Tan & Le (2019b) mix up multiple kernel sizes in a single convolution. Chen et al. (2020a) trades massive multiplications for much cheaper additions. Han et al. (2020) applies a series of cheap linear transformations to generate ghost feature maps. Zhou et al. (2020) flips the structure of inverted residual blocks to alleviate information loss. Yu et al. (2019) and Cai et al. (2019) train one network that supports multiple sub-networks of different complexities. ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Matrix Decomposition: Lebedev et al. (2014) and Denton et al. (2014) use Canonical Polyadic decomposition (CPD) of convolution kernels to speed up networks, while Kim et al. (2015) investigates Tucker decompositions for the same purpose. More recently, Kossaifi et al. (2020) combines tensor decompositions with MobileNet to design efficient higher-order networks for video tasks, while Phan et al. (2020) proposes a stable CPD to deal with degeneracies of tensor decompositions during network training. Unlike DCD, which decomposes a convolutional kernel dynamically by adapting the core matrix to the input, these works all rely on static decompositions. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Dynamic Neural Networks: Dynamic networks boost representation power by adapting parameters or activation functions to the input. Ha et al. (2017) uses a secondary network to generate parameters for the main network. Hu et al. (2018) reweights channels by squeezing global context. Li et al. (2019) adapts attention over kernels of different sizes. Dynamic convolution (Yang et al., 2019; Chen et al., 2020c) aggregates multiple convolution kernels based on attention. Ma et al. (2020) uses grouped fully connected layer to generate convolutional weights directly. Chen et al. (2020b) extends dynamic convolution from spatial agnostic to spatial specific. Su et al. (2020) proposes dynamic group convolution that adaptively selects input channels to form groups. Tian et al. (2020) applies dynamic convolution to instance segmentation. Chen et al. (2020d) adapts slopes and intercepts of two linear functions in ReLU (Nair & Hinton, 2010; Jarrett et al., 2009). ",
+        "bbox": [
+            173,
+            208,
+            825,
+            347
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DYNAMIC CONVOLUTION DECOMPOSITION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            367,
+            568,
+            383
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce the dynamic convolution decomposition proposed to address the limitations of vanilla dynamic convolution. For conciseness, we assume a kernel $W$ with the same number of input and output channels $C _ { i n } = C _ { o u t } = C \\mathrm { \\rangle }$ and ignore bias terms. We focus on $1 \\times 1$ convolution in this section and generalize the procedure to $k \\times k$ convolution in the following section. ",
+        "bbox": [
+            174,
+            398,
+            825,
+            454
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 REVISITING VANILLA DYNAMIC CONVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            470,
+            549,
+            486
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Vanilla dynamic convolution aggregates $K$ convolution kennels $\\{ W _ { k } \\}$ with attention scores $\\{ \\pi _ { k } ( \\pmb x ) \\}$ (see Eq. 1). It can be reformulated as adding a dynamic residual to a static kernel, and the dynamic residual can be further decomposed by SVD (see Eq. 3), as shown in Figure 1. This has two limitations. First, the model is not compact. Essentially, $i t$ expands the number of channels by a factor of $K$ and applies dynamic attention over $K$ channel groups. The dynamic residual $U \\mathbf { I I } ( \\mathbf { \\dot { x } } ) S V ^ { T }$ is a $C \\times C$ matrix, of maximum rank $C$ , but sums $K C$ rank-1 matrices, since ",
+        "bbox": [
+            173,
+            496,
+            825,
+            582
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dda71c3350bc2d60bee99523c48807dcd2397af32d7cadfc63d761a2ba6fcab7.jpg",
+        "text": "$$\n\\pmb { W } ( \\pmb { x } ) = \\pmb { W } _ { 0 } + \\pmb { U } \\pmb { \\Pi } ( \\pmb { x } ) \\pmb { S } \\pmb { V } ^ { T } = \\pmb { W } _ { 0 } + \\sum _ { i = 1 } ^ { K C } \\pi _ { \\uparrow i / C | } ( \\pmb { x } ) \\pmb { u } _ { i } s _ { i , i } \\pmb { v } _ { i } ^ { T } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            587,
+            712,
+            631
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { \\Delta } \\mathbf { u } _ { i }$ is the $i ^ { t h }$ column vector of matrix $U$ , ${ \\mathbf { } } v _ { i }$ is the $i ^ { t h }$ column vector of matrix $V$ , $s _ { i , i }$ is the $i ^ { t h }$ diagonal entry of matrix $_ { s }$ and $\\lceil \\cdot \\rceil$ is ceiling operator. The static basis vectors $\\mathbf { \\Delta } \\mathbf { u } _ { i }$ and ${ \\mathbf { } } v _ { i }$ are not shared across different rank-1 matrices $( \\pi _ { \\lceil i / C \\rceil } ( \\pmb { x } ) \\pmb { u } _ { i } s _ { i , i } \\pmb { v } _ { i } ^ { T } )$ . This results in model redundancy. Second, it is difficult to jointly optimize static matrices $U$ , $V$ and dynamic attention $\\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\mathbf { \\Pi } \\pi \\mathbf { \\Pi } \\mathbf { \\Pi } \\left( \\pmb { x } \\right)$ . This is because a small attention score $\\pi _ { \\lceil i / C \\rceil }$ may suppress the learning of corresponding columns $\\mathbf { \\Delta } \\mathbf { u } _ { i }$ , ${ \\mathbf { } } v _ { i }$ in $U$ and $V$ , especially in early training epochs (as shown in Chen et al. (2020c)). ",
+        "bbox": [
+            173,
+            636,
+            825,
+            724
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 DYNAMIC CHANNEL FUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            741,
+            415,
+            755
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose to address the limitations of the vanilla dynamic convolution with a dynamic channel fusion mechanism, implemented with a full matrix $\\Phi ( { \\pmb x } )$ , where each element $\\phi _ { i , j } ( \\pmb { x } )$ is a function of input $_ { \\textbf { \\em x } }$ . $\\Phi ( { \\pmb x } )$ is a $L \\times L$ matrix, dynamically fusing channels in the latent space $\\mathbb { R } ^ { L }$ . The key idea is to significantly reduce dimensionality in the latent space, $L \\ll C$ , to enable a more compact model. Dynamic convolution is implemented with dynamic channel fusion using ",
+        "bbox": [
+            174,
+            766,
+            825,
+            838
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4bc50116bc9db9b0b10ff4d7ab028d674e67fde34295499df32bb6b1636113fc.jpg",
+        "text": "$$\n\\pmb { W } ( \\pmb { x } ) = \\pmb { W } _ { 0 } + \\pmb { P } \\pmb { \\Phi } ( \\pmb { x } ) \\pmb { Q } ^ { T } = \\pmb { W } _ { 0 } + \\sum _ { i = 1 } ^ { L } \\sum _ { j = 1 } ^ { L } \\pmb { p } _ { i } \\phi _ { i , j } ( \\pmb { x } ) \\pmb { q } _ { j } ^ { T } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            843,
+            696,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $Q \\in \\mathbb { R } ^ { C \\times L }$ compresses the input into a low dimensional space $( Q ^ { T } \\pmb { x } \\in \\mathbb { R } ^ { L } )$ , the resulting $L$ channels are fused dynamically by $\\bar { \\Phi } ( { \\boldsymbol { x } } ) \\in \\mathbb { R } ^ { L \\times L }$ and expanded to the number of output channels by $\\pmb { P } \\in \\mathbb { R } ^ { C \\times L }$ . This is denoted as dynamic convolution decomposition (DCD). The dimension $L$ of the latent space is constrained by $\\dot { L } ^ { 2 } < C$ . The default value of $L$ in this paper is empirically set to b Cblog √Cc c, which means dividing C by 2 repeatedly until it is less than C. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            148
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "With this new design, the number of static parameters is significantly reduced (i.e. $L C$ parameters in $_ { r }$ or $\\textit { \\textbf { Q } } \\nu . s$ . $K C ^ { 2 }$ parameters in $U$ or $V$ , $L ~ < ~ \\sqrt { C } )$ , resulting in a more compact model. Mathematically, the dynamic residual $P \\Phi ( { \\pmb x } ) Q ^ { T }$ sums $L ^ { 2 }$ rank-1 matrices ${ \\pmb p } _ { i } \\phi _ { i , j } ( { \\pmb x } ) { \\pmb q } _ { j } ^ { T }$ , where $\\mathbf { \\nabla } _ { \\mathbf { p } _ { i } }$ is the $i ^ { t h }$ column vector of $_ { r }$ , and $\\pmb q _ { j }$ is the $j ^ { t h }$ column vector of $Q$ . The constraint $L ^ { 2 } < C$ , guarantees that this number $( L ^ { 2 } )$ is much smaller than the counterpart $( K C )$ of vanilla dynamic convolution (see Eq. 4). Nevertheless, due to the use of a full matrix, dynamic channel fusion $\\Phi ( { \\pmb x } )$ retains the representation power needed to achieve good classification performance. ",
+        "bbox": [
+            174,
+            156,
+            825,
+            261
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "DCD also mitigates the joint optimization difficulty. Since each column of $_ { r }$ (or $Q$ ) is associated with multiple dynamic coefficients (e.g. $\\mathbf { \\nabla } p _ { i }$ is related to $\\phi _ { i , 1 } , \\ldots , \\phi _ { i , L } )$ , it is unlikely that the learning of $\\pmb { p } _ { i }$ is suppressed by a few dynamic coefficients of small value. ",
+        "bbox": [
+            176,
+            267,
+            821,
+            310
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In summary, DCD performs dynamic aggregation differently from vanilla dynamic convolution. Vanilla dynamic convolution uses a shared dynamic attention mechanism to aggregate unshared static basis vectors in a high dimensional latent space. In contrast, DCD uses an unshared dynamic channel fusion mechanism to aggregate shared static basis vectors in a low dimensional latent space. ",
+        "bbox": [
+            174,
+            316,
+            825,
+            372
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 MORE GENERAL FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            390,
+            439,
+            405
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "So far, we have focused on the dynamic residual and shown that dynamic channel fusion enables a compact implementation of dynamic convolution. We next discuss the static kernel $W _ { 0 }$ . Originally, it is multiplied by a dynamic scalar $\\textstyle \\sum _ { k } \\pi _ { k } ( { \\pmb x } )$ , which is canceled in Eq. 3 as attention scores sum to one. Relaxing the constraint $\\begin{array} { r } { \\sum _ { k } \\pi _ { k } ( \\mathbf { \\bar { x } } ) = 1 } \\end{array}$ results in the more general form ",
+        "bbox": [
+            173,
+            416,
+            825,
+            474
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/593cec9e483680e1d4dadd3d5e541842464f685841587376efd6f7f4318ca391.jpg",
+        "text": "$$\n\\pmb { W } ( \\pmb { x } ) = \\pmb { \\Lambda } ( \\pmb { x } ) \\pmb { W } _ { 0 } + \\pmb { P } \\pmb { \\Phi } ( \\pmb { x } ) \\pmb { Q } ^ { T } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            482,
+            614,
+            501
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { \\Lambda } ( \\pmb { x } )$ is a $C \\times C$ diagonal matrix and $\\lambda _ { i , i } ( \\pmb { x } )$ a function of $_ { \\textbf { \\em x } }$ . In this way, $\\pmb { \\Lambda } ( \\pmb { x } )$ implements channel-wise attention after the static kernel $W _ { 0 }$ , generalizing Eq. 5 where $\\pmb { \\Lambda } ( \\pmb { x } )$ is an identity matrix. Later, we will see that this generalization enables additional performance gains. ",
+        "bbox": [
+            174,
+            508,
+            823,
+            551
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Relation to Squeeze-and-Excitation (SE) (Hu et al., 2018): The dynamic channel-wise attention mechanism implemented by $\\pmb { \\Lambda } ( \\pmb { x } )$ is related to but different from SE. It is parallel to a convolution and shares the input with the convolution. It can be thought of as either a dynamic convolution kernel ${ \\pmb y } = ( { \\pmb \\Lambda } ( { \\pmb x } ) { \\pmb W } _ { 0 } ) { \\pmb x }$ or an input-dependent attention mechanism applied to the output feature map of the convolution ${ \\pmb y } = { \\pmb \\Lambda } ( { \\pmb x } ) ( { \\pmb W } _ { 0 } { \\pmb x } )$ . Thus, its computational complexity is $\\operatorname* { m i n } ( \\mathcal { O } ( C ^ { 2 } ) , \\mathcal { O } ( H W C ) )$ , where $H$ and $W$ are height and width of the feature map. ",
+        "bbox": [
+            173,
+            558,
+            825,
+            642
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In contrast, SE is placed after a convolution and uses the output of the convolution as input. It can only apply channel attention on the output feature map of the convolution as $y = \\pmb { \\Lambda } ( z ) z$ , where $z = W _ { 0 } { \\pmb x }$ . Its computational complexity is $\\mathcal { O } ( H W C )$ . Clearly, SE requires more computation than dynamic channel-wise attention $\\pmb { \\Lambda } ( \\pmb { x } )$ when the resolution of the feature map $( H \\times W )$ is high. ",
+        "bbox": [
+            173,
+            648,
+            825,
+            704
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 DYNAMIC CONVOLUTION DECOMPOSITION LAYER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            568,
+            737
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Implementation: Figure 2 shows the diagram of a dynamic convolution decomposition (DCD) layer. It uses a light-weight dynamic branch to generate coefficients for both dynamic channel-wise attention $\\pmb { \\Lambda } ( \\pmb { x } )$ and dynamic channel fusion $\\Phi ( { \\pmb x } )$ . Similar to Squeeze-and-Excitation (Hu et al., 2018), the dynamic branch first applies average pooling to the input $_ { \\textbf { \\em x } }$ . This is followed by two fully connected (FC) layers with an activation layer between them. The first FC layer reduces the number of channels by $r$ and the second expands them into $C + L ^ { 2 }$ outputs $C$ for $\\pmb { \\Lambda }$ and $L ^ { 2 }$ for $\\Phi$ ). Eq. 6 is finally used to generate convolutional weights $W ( { \\pmb x } )$ . Similarly to a static convolution, a DCD layer also includes a batch normalization and an activation (e.g. ReLU) layer. ",
+        "bbox": [
+            173,
+            748,
+            825,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Parameter Complexity: DCD has similar FLOPs to the vanilla dynamic convolution. Here, we focus on parameter complexity. Static convolution and vanilla dynamic convolution require $C ^ { 2 }$ and $K C ^ { 2 }$ parameters, respectively. DCD requires $C ^ { 2 }$ , $C L$ , and $C L$ parameters for static matrices $W _ { 0 }$ , $_ { P }$ and $Q$ , respectively. An additional $( 2 C + L ^ { 2 } ) \\frac { C } { r }$ parameters are required by the dynamic branch to generate $\\pmb { \\Lambda } ( \\pmb { x } )$ and $\\Phi ( { \\pmb x } )$ , where $r$ is the reduction rate of the first FC layer. The total complexity is $\\begin{array} { r } { C ^ { 2 } + 2 C L + ( 2 C + L ^ { 2 } ) \\frac { C } { r } } \\end{array}$ . Since $L$ is constrained as $L ^ { 2 } < C$ , the complexity upper bound is $( 1 + \\textstyle { \\frac { 3 } { r } } ) C ^ { 2 } + 2 C \\sqrt { C }$ . When choosing $r = 1 6$ , the complexity is about $1 \\frac { 3 } { 1 6 } C ^ { 2 }$ . This is much less than what is typical for vanilla dynamic convolution ( $\\mathrm { 4 } C ^ { 2 }$ in Chen et al. (2020c) and $8 C ^ { 2 }$ in Yang et al. (2019)). ",
+        "bbox": [
+            174,
+            867,
+            823,
+            925
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/095999c82ca5e0d58772ecf92bdc8c6fe722550a4713cd3785573d0e790c9fc8.jpg",
+        "image_caption": [
+            "Figure 2: Dynamic convolution decomposition layer. The input $_ { \\textbf { \\em x } }$ first goes through a dynamic branch to generate $\\pmb { \\Lambda } ( \\pmb { x } )$ and $\\Phi ( { \\pmb x } )$ , and then to generate the convolution matrix $W ( { \\pmb x } )$ using Eq. 6. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            106,
+            504,
+            231
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/6834050855ca91a52cf123cbc6cce2dc0b03af42aa810758a845d0d9d321091d.jpg",
+        "image_caption": [
+            "Figure 3: Sparse dynamic residual, which is represented as a diagonal block matrix. Each diagonal block is decomposed separately as $\\bar { P } _ { b } \\Phi _ { b } Q _ { b } ^ { T }$ . Note that the static kernel $W _ { 0 }$ is still a full size matrix. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            547,
+            135,
+            828,
+            220
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            330,
+            826,
+            410
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXTENSIONS OF DYNAMIC CONVOLUTION DECOMPOSITION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            433,
+            707,
+            450
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we extend the dynamic decomposition of $1 \\times 1$ convolution (Eq. 6) in three ways: (a) sparse dynamic residual where $P \\Phi ( { \\pmb x } ) Q ^ { \\dagger }$ is a diagonal block matrix, (b) $k \\times k$ depthwise convolution, and (c) $k \\times k$ convolution. Here, $k$ refers to the kernel size. ",
+        "bbox": [
+            173,
+            467,
+            825,
+            510
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DCD WITH SPARSE DYNAMIC RESIDUAL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            530,
+            500,
+            545
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The dynamic residual $P \\Phi ( { \\pmb x } ) Q ^ { T }$ can be further simplified into a block-diagonal matrix of blocks $P _ { b } \\Phi _ { b } ( { \\boldsymbol { x } } ) Q _ { b } ^ { T } , b \\in \\{ 1 , . . . , \\dot { B } \\}$ , leading to ",
+        "bbox": [
+            174,
+            556,
+            823,
+            587
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/256a47b9c355b729c7b4a4c10cf4e08e5f3ddf8261e8bddc39513d32ef3403e9.jpg",
+        "text": "$$\nW ( \\pmb { x } ) = \\Lambda ( \\pmb { x } ) W _ { 0 } + \\bigoplus _ { b = 1 } ^ { B } P _ { b } \\Phi _ { b } ( \\pmb { x } ) Q _ { b } ^ { T } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            597,
+            633,
+            642
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\bigoplus _ { i = 1 } ^ { n } A _ { i } = d i a g ( A _ { 1 } , \\ldots , A _ { n } )$ . This form has Eq. 6 as a special case, where $B = 1$ . Note that the static kernel $W _ { 0 }$ is still a full matrix and only the dynamic residual is sparse (see Figure 3). We will show later that keeping as few as $\\frac { 1 } { 8 }$ of the entries of the dynamic residual non-zero ( $B = 8$ ) has a minimal performance degradation, still significantly outperforming a static kernel. ",
+        "bbox": [
+            173,
+            651,
+            825,
+            708
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 DCD OF $k \\times k$ DEPTHWISE CONVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            728,
+            511,
+            744
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The weights of a $k \\times k$ depthwise convolution kernel form a $C \\times k ^ { 2 }$ matrix. DCD can be generalized to such matrices by replacing in Eq. 6 the matrix $Q$ (which squeezes the number of channels) with a matrix $\\pmb { R }$ (which squeezes the number of kernel elements) ",
+        "bbox": [
+            173,
+            756,
+            825,
+            799
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8ae1db8a08f7990202baad5af090f0805cf773320d580d74fe5de05234eb7cc9.jpg",
+        "text": "$$\n\\begin{array} { r } { \\pmb { W } ( \\pmb { x } ) = \\pmb { \\Lambda } ( \\pmb { x } ) \\pmb { W } _ { 0 } + \\pmb { P } \\pmb { \\Phi } ( \\pmb { x } ) \\pmb { R } ^ { T } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            809,
+            616,
+            829
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $W ( { \\pmb x } )$ and $W _ { 0 }$ are $C \\times k ^ { 2 }$ matrices, $\\Lambda ( x )$ is a diagonal $C \\times C$ matrix that implements channel-wise attention, $\\pmb { R }$ is a $k ^ { 2 } \\times L _ { k }$ matrix that reduces the number of kernel elements from $k ^ { 2 }$ to $L _ { k }$ , $\\Phi ( x )$ is a $L _ { k } \\times L _ { k }$ matrix that performs dynamic fusion along $L _ { k }$ latent kernel elements and $_ { r }$ is a $C \\times L _ { k }$ weight matrix for depthwise convolution over $L _ { k }$ kernel elements. The default value of $L _ { k }$ is $\\lfloor k ^ { 2 } / 2 \\rfloor$ . Since depthwise convolution is channel separable, $\\Phi ( x )$ does not fuse channels, fusing instead $L _ { k }$ latent kernel elements. ",
+        "bbox": [
+            173,
+            838,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/8df9ba9a9296643849764ddae81071ae4a777206b079a6f48817156020193453.jpg",
+        "image_caption": [
+            "Figure 4: The dynamic convolution decomposition for $k \\times k$ convolution. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            102,
+            810,
+            284
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 DCD OF $k \\times k$ CONVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            335,
+            424,
+            351
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Joint fusion of channels and kernel elements: A $k \\times k$ convolution kernel forms a $C \\times C \\times k ^ { 2 }$ tensor. DCD can be generalized to such tensors by extending Eq. 6 into a tensor form (see Figure 4) ",
+        "bbox": [
+            171,
+            366,
+            823,
+            395
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c28b5b9fd42e5a463d9bcd4665f14975c4d7a7c6a6fb47cc21a9df72bbf2fd12.jpg",
+        "text": "$$\nW ( { \\pmb x } ) = W _ { 0 } \\times _ { 2 } \\Lambda ( { \\pmb x } ) + \\Phi ( { \\pmb x } ) \\times _ { 1 } { \\pmb Q } \\times _ { 2 } { \\pmb P } \\times _ { 3 } { \\pmb R } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            410,
+            671,
+            428
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\times _ { n }$ refers to $n$ -mode multiplication (Lathauwer et al., 2000), $W _ { 0 }$ is a $C \\times C \\times k ^ { 2 }$ tensor, $\\Lambda ( x )$ is a diagonal $C \\times C$ matrix that implements channel-wise attention, $Q$ is a $C \\times L$ matrix that reduces the number of input channels from $C$ to $L , R$ is a $k ^ { 2 } \\times L _ { k }$ matrix that reduces the number of kernel elements from $k ^ { 2 }$ to $L _ { k }$ , $\\Phi ( x )$ is a $L \\times L \\times L _ { k }$ tensor that performs joint fusion of $L$ channels over $L _ { k }$ latent kernel elements, and $_ { r }$ is a $C \\times L$ matrix that expands the number of channels from $L$ to $C$ . The numbers of latent channels $L$ and latent kernel elements $L _ { k }$ are constrained by $L _ { k } < k ^ { 2 }$ and $L ^ { 2 } L _ { k } \\le C$ . Their default values are set empirically to $L _ { k } = \\lfloor k ^ { 2 } / 2 \\rfloor$ , $\\begin{array} { r } { L = \\lfloor \\frac { C / L _ { k } ^ { \\top } } { 2 ^ { \\lfloor l o g _ { 2 } \\sqrt { C / L _ { k } } \\rfloor } } \\rfloor } \\end{array}$ ",
+        "bbox": [
+            173,
+            443,
+            825,
+            549
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Channel fusion alone: We found that the fusion of channels $\\Phi ( { \\pmb x } ) \\times _ { 1 } Q$ is more important than the fusion of kernel elements $\\Phi ( { \\pmb x } ) \\times _ { 3 } R$ . Therefore, we reduce $L _ { k }$ to 1 and increase $L$ accordingly. $\\pmb { R }$ is simplified into a one-hot vector $[ 0 , \\ldots , 0 , 1 , 0 , \\ldots , 0 ] ^ { T }$ , where the ‘1’ is located at the center (assuming that $k$ is an odd number). As illustrated in Figure 4-(b), the tensor of dynamic residual $\\Phi ( { \\pmb x } ) \\times _ { 1 } { \\pmb Q } \\times _ { 2 } { \\pmb P } \\times _ { 3 } { \\pmb R }$ only has one non-zero slice, which is equivalent to a $1 \\times 1$ convolution. Therefore, the DCD of a $k \\times k$ convolution is essentially adding a $1 \\times 1$ dynamic residual to a static $k \\times k$ kernel. ",
+        "bbox": [
+            173,
+            555,
+            825,
+            654
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            683,
+            326,
+            699
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present the results of DCD on ImageNet classification (Deng et al., 2009). ImageNet has 1,000 classes with 1,281,167 training and 50, 000 validation images. We also report ablation studies on different components of the approach. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            762
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "All experiments are based on two network architectures: ResNet (He et al., 2016) and MobileNetV2 (Sandler et al., 2018). DCD is implemented on all convolutional layers of ResNet and all $1 \\times 1$ convolutional layers of MobileNetV2. The reduction ratio $r$ is set to 16 for ResNet and MobileNetV2 $\\times 1 . 0$ , and to 8 for smaller models (MobileNetV2 $\\times 0 . 5$ and $\\times 0 . 3 5 )$ ). All models are trained by SGD with momentum 0.9. The batch size is 256 and remaining training parameters are as follows. ",
+        "bbox": [
+            174,
+            770,
+            823,
+            840
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "ResNet: The learning rate starts at 0.1 and is divided by 10 every 30 epochs. The model is trained with 100 epochs. Dropout (Srivastava et al., 2014) 0.1 is used only for ResNet-50. ",
+        "bbox": [
+            173,
+            845,
+            821,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "MobileNetV2: The initial learning rate is 0.05 and decays to 0 in 300 epochs, according to a cosine function. Weight decay of 2e-5 and a dropout rate of 0.1 are also used. For MobileNetV2 $\\times 1 . 0$ Mixup (Zhang et al., 2018a) and label smoothing are further added to avoid overfitting. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/289c4f2a0e16e5de705f1153be49c18ad7cd1a8ab26d38093e637c92a73d53c7.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Params MAdds</td><td>Top-1</td></tr><tr><td>Wo (static)</td><td>2.0M 97.0M</td><td>65.4</td></tr><tr><td>AWo</td><td>2.4M 97.4M</td><td>68.2</td></tr><tr><td>W+PΦQT</td><td>2.7M 104.4M</td><td>69.2</td></tr><tr><td>AW+PΦQT</td><td>2.9M 104.6M</td><td>69.8</td></tr></table>",
+        "bbox": [
+            173,
+            128,
+            482,
+            202
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/2246432ac293901e9f6c7dee19fdd1ad81d52217732fa23d0290bdcc56c388b2.jpg",
+        "table_caption": [
+            "Table 1: Different formulations of dynamic convolution decomposition on ImageNet classification. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Params</td><td>MAdds</td><td>Top-1</td></tr><tr><td>Wo (static)</td><td>11.1M</td><td>1.81G</td><td>70.4</td></tr><tr><td>AWo</td><td>11.7M</td><td>1.81G</td><td>71.5</td></tr><tr><td>Wo+PΦQT</td><td>13.6M</td><td>1.83G</td><td>72.8</td></tr><tr><td>AW+PΦQT</td><td>14.0M</td><td>1.83G</td><td>73.1</td></tr></table>",
+        "bbox": [
+            511,
+            127,
+            816,
+            200
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(a) MobileNet ${ \\bf V } 2 \\times 0 . 5$ ",
+        "text_level": 1,
+        "bbox": [
+            254,
+            213,
+            400,
+            227
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(b) ResNet-18 ",
+        "text_level": 1,
+        "bbox": [
+            619,
+            212,
+            709,
+            224
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 INSPECTING DIFFERENT DCD FORMULATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            238,
+            540,
+            252
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1 summarizes the influence of different components (e.g. dynamic channel fusion $\\Phi ( { \\pmb x } )$ , dynamic channel-wise attention $\\pmb { \\Lambda } ( \\pmb { x } ) )$ ) of DCD on MobileNet ${ \\bf V } 2 \\times 0 . 5$ and ResNet-18 performance. The table shows that both dynamic components, $\\pmb { \\Lambda } ( \\pmb { x } )$ and $\\Phi ( { \\pmb x } )$ of Eq. 6. enhance accuracy substantially $( + 2 . 8 \\%$ and $+ 3 . 8 \\%$ for MobileNetV2 $\\times 0 . 5$ , $+ 1 . 1 \\%$ and $+ 2 . 4 \\%$ for ResNet-18), when compared to the static baseline. Using dynamic channel fusion only $( W _ { 0 } + P \\Phi Q ^ { T } )$ has slightly more parameters, FLOPs, and accuracy than using dynamic channel-wise attention only $( \\Lambda W _ { 0 } )$ . The combination of the two mechanisms provides additional improvement. ",
+        "bbox": [
+            173,
+            263,
+            825,
+            362
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 ABLATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            381,
+            297,
+            395
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A number of ablations were performed on MobileNet ${ \\bf V } 2 { \\bf \\Psi } \\times 0 . 5$ to analyze DCD performance in terms of two questions. ",
+        "bbox": [
+            173,
+            407,
+            823,
+            435
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1. How does the dimension $( L )$ of the latent space affect performance? ",
+        "bbox": [
+            212,
+            448,
+            679,
+            463
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "2. How do three DCD variants perform? ",
+        "bbox": [
+            214,
+            469,
+            482,
+            484
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The default configuration is the general form of DCD (Eq. 6) with a full size dynamic residual $B = 1$ ) for all pointwise convolution layers. The default latent space dimension is $\\begin{array} { r } { \\dot { L } = \\lfloor \\frac { C } { 2 ^ { \\lfloor l o g _ { 2 } \\sqrt { C } \\rfloor } } \\rfloor } \\end{array}$ ",
+        "bbox": [
+            174,
+            496,
+            826,
+            525
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Latent Space Dimension $L$ : The dynamic channel fusion matrix $\\Phi ( { \\pmb x } )$ has size $L \\times L$ . Thus, $L$ controls both the representation and the parameter complexity of DCD. We adjust it by applying different multipliers to the default value of $L$ . Table 2 shows the results of MobileNetV2 $\\times 0 . 5$ for four multiplier values ranging from $\\times 1 . 0$ to $\\times 0 . 2 5$ . As $L$ decreases, fewer parameters are required and the performance degrades slowly. Even with a very low dimensional latent space $( L \\times 0 . 2 5 )$ , DCD still outperforms the static baseline by $3 . 3 \\%$ top-1 accuracy. ",
+        "bbox": [
+            174,
+            535,
+            496,
+            702
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/46dbd16e31079bcd1dcaaca454c3f199c67367183bc9e6a5916f62ef5f9735e6.jpg",
+        "table_caption": [
+            "Table 2: Dimension of the latent space $L$ evaluated on ImageNet classification (MobileNetV2 $\\times 0 . 5$ is used). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>L</td><td>Params</td><td>MAdds</td><td>Top-1</td></tr><tr><td>static</td><td>-</td><td>2.0M</td><td>97.0M</td><td>65.4</td></tr><tr><td rowspan=\"4\">DCD</td><td>×0.25</td><td>2.4M</td><td>99.8M</td><td>68.7</td></tr><tr><td>×0.50</td><td>2.5M</td><td>101.3M</td><td>69.0</td></tr><tr><td>×0.75</td><td>2.6M</td><td>102.9M</td><td>69.6</td></tr><tr><td>×1.0</td><td>2.9M</td><td>104.6M</td><td>69.8</td></tr></table>",
+        "bbox": [
+            511,
+            603,
+            820,
+            684
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Number of Diagonal Blocks $B$ in the Dynamic ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            708,
+            496,
+            722
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Residual: Table 3-(a) shows classification results for four values of $B$ . The dynamic residual is a full matrix when $B = 1$ , while only $\\frac { 1 } { 8 }$ of its entries are non-zero for $B = 8$ . Accuracy degrades slowly as the dynamic residual becomes sparser (increasing $B$ ). The largest performance drop happens when $B$ is changed from 1 to 2, as half of the weight matrix $W ( { \\pmb x } )$ becomes static. However, performance is still significantly better than that of the static baseline. The fact that even the sparsest $B = 8$ outperforms the static baseline by $2 . 9 \\%$ (from $6 5 . 4 \\%$ to $6 8 . 3 \\%$ ) demonstrates the representation power of the dynamic residual. In all cases, dynamic channel-wise attention $\\pmb { \\Lambda } ( \\pmb { x } )$ enables additional performance gains. ",
+        "bbox": [
+            173,
+            723,
+            825,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "DCD at Different Layers: Table 3-(b) shows the results of implementing DCD for three different types of layers (a) DW: depthwise convolution (Eq. 8), (b) PW: pointwise convolution (Eq. 6), and (c) CLS: fully connected classifier, which is a special case of pointwise convolution (the input resolution is $1 \\times 1$ ). Using DCD in any type of layer improves on the performance of the static baseline $( + 2 . 9 \\%$ for depthwise convolution, $+ 4 . 4 \\%$ for pointwise convolution, and $+ 1 . 2 \\%$ for classifier). Combining DCD for both pointwise convolution and classifier achieves the best performance ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/202f27d4918a5fcd703ccd2573782786196a90cb87abfeb86a0a6d61db31f6f7.jpg",
+        "table_caption": [
+            "Table 3: Extensions of dynamic convolution decompostion (DCD) evaluated on ImageNet classification (MobileNetV2 $\\times 0 . 5$ is used). "
+        ],
+        "table_footnote": [
+            "$\\mathbf { ( b ) }$ DCD at different layers. DW, PW, and CLS indicate depthwise convolution, pointwise convolution and classifier respectively. "
+        ],
+        "table_body": "<table><tr><td>Network</td><td>B</td><td>Params</td><td>MAdds</td><td>Top-1</td></tr><tr><td>Wo (static)</td><td>-</td><td>2.0M</td><td>97.0M 65.4</td><td></td></tr><tr><td rowspan=\"4\">Wo + PΦQT</td><td>1</td><td>2.7M</td><td>104.4M</td><td>69.2</td></tr><tr><td>2</td><td>2.6M</td><td>101.0M</td><td>68.5</td></tr><tr><td>4</td><td>2.5M</td><td>99.1M</td><td>68.4</td></tr><tr><td>8</td><td>2.5M</td><td>98.5M</td><td>68.3</td></tr><tr><td rowspan=\"4\">AWo+PΦQT</td><td>1</td><td>2.9M</td><td>104.6M</td><td>69.8</td></tr><tr><td>2</td><td>2.8M</td><td>101.3M</td><td>68.9</td></tr><tr><td>4</td><td>2.7M</td><td>99.4M</td><td>68.8</td></tr><tr><td>8</td><td>2.7M</td><td>98.8M</td><td>68.5</td></tr></table>",
+        "bbox": [
+            173,
+            145,
+            498,
+            276
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(a) Number of diagonal blocks $B$ in the dynamic residual. ",
+        "text_level": 1,
+        "bbox": [
+            181,
+            287,
+            488,
+            315
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/bff94169cd5aadf4a41f774495391fdaa895ccc31e6e0eb3f1ae4c6851341d61.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>DW</td><td>PW</td><td>CLS</td><td>Params MAdds</td><td>Top-1</td></tr><tr><td></td><td></td><td>2.0M</td><td>97.0M</td><td>65.4</td></tr><tr><td>√</td><td></td><td>2.4M</td><td>97.5M</td><td>68.3</td></tr><tr><td></td><td>√</td><td></td><td>2.9M 104.6M</td><td>69.8</td></tr><tr><td></td><td></td><td>√</td><td>2.2M 97.2M</td><td>66.6</td></tr><tr><td>√</td><td></td><td>√</td><td>2.6M 97.7M</td><td>69.0</td></tr><tr><td>√</td><td>√</td><td></td><td>3.3M 105.1M</td><td>69.6</td></tr><tr><td></td><td>√</td><td>√</td><td>3.1M 104.8M</td><td>70.2</td></tr><tr><td>√</td><td>√</td><td>√</td><td>3.5M 105.3M</td><td>70.0</td></tr></table>",
+        "bbox": [
+            508,
+            145,
+            816,
+            267
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e20680d3de6ac454d5347ed53225e7c7499769d1861ebb67d5c56eead34fe880.jpg",
+        "table_caption": [
+            "Table 4: Comparing DCD with the vanilla dynamic convolution CondConv (Yang et al., 2019) and DY-Conv (Chen et al., 2020c). ✶indicates the dynamic model with the fewest parameters (static model is not included). CondConv contains $K = 8$ kernels and DY-Conv contains $K = 4$ kernels. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Width</td><td>Model</td><td>Params</td><td>MAdds</td><td>Top-1</td></tr><tr><td>×1.0</td><td>static DY-Conv CondConv DCD (ours)</td><td>3.5M 300.0M 11.1M 312.9M 27.5M 329.0M *5.5M 326.0M</td><td></td><td>72.0 75.2 74.6 75.2</td></tr><tr><td>×0.5</td><td>static DY-Conv CondConv DCD (ours)</td><td>2.0M 4.0M 15.5M *3.1M</td><td>97.0M 101.4M 113.0M 104.8M</td><td>65.4 69.9 68.4 70.2</td></tr><tr><td>×0.35</td><td>static DY-Conv DCD (ours)</td><td>1.7M 2.8M *2.3M</td><td>59.2M 62.0M 63.1M</td><td>60.3 65.9 66.6</td></tr></table>",
+        "bbox": [
+            183,
+            400,
+            483,
+            559
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/27a4ca505b29f8db1662730a22590516bb6e1f0c19af8c1ee722a8a6dd027109.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Depth</td><td>Model</td><td>Params</td><td>MAdds</td><td>Top-1</td></tr><tr><td rowspan=\"2\">ResNet-50</td><td>static</td><td>23.5M</td><td>3.8G</td><td>76.2</td></tr><tr><td>DCD (ours)</td><td>30.7M</td><td>3.9G</td><td>77.9</td></tr><tr><td rowspan=\"3\">ResNet-18</td><td>static</td><td>11.1M</td><td>1.81G</td><td>70.4</td></tr><tr><td>DY-Conv</td><td>42.7M</td><td>1.85G</td><td>72.7</td></tr><tr><td>DCD (ours)</td><td>*14.0M</td><td>1.83G</td><td>73.1</td></tr><tr><td rowspan=\"3\">ResNet-10</td><td>static</td><td>5.2M</td><td>0.89G</td><td>63.5</td></tr><tr><td>DY-Conv</td><td>18.6M</td><td>0.91G</td><td>67.7</td></tr><tr><td>DCD (ours)</td><td>*6.5M</td><td>0.90G</td><td>68.8</td></tr></table>",
+        "bbox": [
+            493,
+            438,
+            823,
+            559
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(a) MobileNetV2. ",
+        "text_level": 1,
+        "bbox": [
+            279,
+            569,
+            387,
+            583
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(b) ResNet. ",
+        "bbox": [
+            622,
+            570,
+            694,
+            583
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "$( + 4 . 8 \\% )$ . We notice a performance drop (from $7 0 . 2 \\%$ to $7 0 . 0 \\%$ ) when using DCD in all three types of layers. We believe this is due to overfitting, as it has higher training accuracy. ",
+        "bbox": [
+            173,
+            607,
+            823,
+            636
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Extension to $3 \\times 3$ Convolution: We use ResNet-18, which stacks 16 layers of $3 \\times 3$ convolution, to study the $3 \\times 3$ extension of DCD (see Section 4.3). Compared to the static baseline $7 0 . 4 \\%$ top-1 accuracy), DCD with joint fusion of channels and kernel elements (Eq. 9) improves top-1 accuracy $( 7 1 . 3 \\% )$ by $0 . 9 \\%$ . The top-1 accuracy is further improved by $1 . 8 \\%$ $( 7 3 . 1 \\% )$ , when using DCD with channel fusion alone, which transforms the dynamic residual as a $1 \\times 1$ convolution matrix (see Figure 4-(b)). This demonstrates that dynamic fusion is more effective across channels than across kernel elements. ",
+        "bbox": [
+            173,
+            642,
+            825,
+            739
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Summary: Based on the ablations above, DCD should be implemented with both dynamic channel fusion $\\Phi$ and dynamic channel-wise attention $\\pmb { \\Lambda }$ , the default latent space dimension $L$ , and a full size residual $B = 1$ . DCD is recommended for pointwise convolution and classifier layers in MobileNetV2. For $3 \\times 3$ convolutions in ResNet, DCD should be implemented with channel fusion alone. The model can be made more compact, for a slight performance drop, by (a) removing dynamic channel-wise attention $\\pmb { \\Lambda }$ , (b) reducing the latent space dimension $L$ , (c) using a sparser dynamic residual (increasing $B$ ), and (d) implementing DCD in depthwise convolution alone. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            844
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 MAIN RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            871,
+            321,
+            885
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "DCD was compared to the vanilla dynamic convolution (Yang et al., 2019; Chen et al., 2020c) for MobileNetV2 and ResNet, using the settings recommended above, with the results of ",
+        "bbox": [
+            173,
+            900,
+            826,
+            929
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table $4 ^ { 1 }$ . DCD significantly reduces the number of parameters while improving the performance of both network architectures. For MobileNetV2 $\\times 1 . 0$ , DCD only requires $50 \\%$ of the parameters of (Chen et al., 2020c) and $2 5 \\%$ of the parameters of (Yang et al., 2019). For ResNet-18, it only requires $33 \\%$ of the parameters of (Chen et al., 2020c), while achieving a $0 . 4 \\%$ gain in top-1 accuracy. Although DCD requires slightly more MAdds than (Chen et al., 2020c), the increment is negligible. These results demonstate that DCD is more compact and effective. ",
+        "bbox": [
+            174,
+            103,
+            562,
+            242
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 compares DCD to DY-Conv (Chen et al., 2020c) in terms of training convergence. DY-Conv uses a large temperature in its softmax to alleviate the joint optimization difficulty and make training more efficient. Without any additional parameter tuning, DCD converges even faster than DY-Conv with a large temperature and achieves higher accuracy. ",
+        "bbox": [
+            174,
+            250,
+            560,
+            347
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/99e5e2fe3eb00d74cf9d49d1f2c23341d4a0d8e6e63a8b648648b65579c58e94.jpg",
+        "image_caption": [
+            "Figure 5: The comparison of training and validation error between DCD and DY-Conv on MobileNetV2 $\\times 0 . 5$ . $\\tau$ is the temperature in softmax. Best viewed in color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            576,
+            106,
+            820,
+            255
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 ANALYSIS OF DYNAMIC CHANNEL FUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            363,
+            514,
+            377
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To validate the dynamic property, $\\Phi ( { \\pmb x } )$ should have different values over different images. We measure this by averaging the variance of each entry $\\begin{array} { r } { \\sigma _ { \\Phi } = \\sum _ { i , j } \\sigma _ { i , j } / L ^ { 2 } } \\end{array}$ where $\\sigma _ { i , j }$ is the variance of $\\phi _ { i , j } ( \\pmb { x } )$ , over all validation images. To compare $\\sigma _ { \\Phi }$ across layers, we normalize it by the variance of the corresponding input feature map. Figure 6 shows the normalized variance $\\sigma _ { \\Phi }$ across layers in MobileNetV2. Clearly, the dynamic coefficients vary more in the higher layers. We believe this is because the higher layers encode more context information, providing more clues to adapt convolution weights. ",
+        "bbox": [
+            174,
+            390,
+            562,
+            545
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.5 INFERENCE TIME ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            561,
+            334,
+            575
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/aa040ac66e6659fc2e58dee51bb5627be93880e67fb707a48e441a14afb395e8.jpg",
+        "image_caption": [
+            "Figure 6: Normalized variance of dynamic coefficients $\\sigma _ { \\Phi }$ across layers in MobileNetV2 $\\times 0 . 5$ and $\\times 1 . 0$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            580,
+            375,
+            818,
+            523
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We use a single-threaded core AMD EPYC CPU 7551P $( 2 . 0 \\mathrm { G H z } )$ to measure running time (in milliseconds) on MobileNetV2 $\\times 0 . 5$ and $\\times 1 . 0$ . Running time is calculated by averaging the inference time of 5,000 images with batch size 1. Both static baseline and DCD are implemented in PyTorch. Compared with the static baseline, DCD consumes about $8 \\%$ more MAdds (97.0M vs 104.8M) and $14 \\%$ more running time (91ms vs $\\mathrm { 1 0 4 m s ) }$ for Mobile ${ \\mathrm { N e t V } } 2 \\times 0 . 5$ . For MobileNetV2 $\\times 1 . 0$ , DCD consumes $9 \\%$ more MAdds (300.0M vs 326.0M) and $12 \\%$ more running time (146ms vs $1 6 3 \\mathrm { m s }$ ). The overhead is higher in running time than MAdds. We believe this is because the optimizations of global average pooling and fully connected layers are not as efficient as convolution. This small penalty in inference time is justified by the DCD gains of $4 . 8 \\%$ and $3 . 2 \\%$ top-1 accuracy over MobileNetV2 $\\times 0 . 5$ and $\\times 1 . 0$ respectively. ",
+        "bbox": [
+            173,
+            587,
+            825,
+            727
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            746,
+            318,
+            762
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have revisited dynamic convolution via matrix decomposition and demonstrated the limitations of dynamic attention over channel groups: it multiplies the number of parameters by $K$ and increases the difficulty of joint optimization. We proposed a dynamic convolution decomposition to address these issues. This applies dynamic channel fusion to significantly reduce the dimensionality of the latent space, resulting in a more compact model that is easier to learn with often improved accuracy. We hope that our work provides a deeper understanding of the gains recently observed for dynamic convolution. ",
+        "bbox": [
+            173,
+            777,
+            825,
+            875
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Han Cai, Chuang Gan, and Song Han. Once for all: Train one network and specialize it for efficient deployment. ArXiv, abs/1908.09791, 2019. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hanting Chen, Yunhe Wang, Chunjing Xu, Boxin Shi, Chao Xu, Qi Tian, and Chang Xu. Addernet: Do we really need multiplications in deep learning? In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020a. ",
+        "bbox": [
+            171,
+            162,
+            821,
+            207
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jyun-Ruei Chen, Xijun Wang, Zichao Guo, X. Zhang, and J. Sun. Dynamic region-aware convolution. ArXiv, abs/2003.12243, 2020b. ",
+        "bbox": [
+            169,
+            214,
+            823,
+            244
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yinpeng Chen, Xiyang Dai, Mengchen Liu, Dongdong Chen, Lu Yuan, and Zicheng Liu. Dynamic convolution: Attention over convolution kernels. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020c. ",
+        "bbox": [
+            174,
+            252,
+            825,
+            295
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yinpeng Chen, Xiyang Dai, Mengchen Liu, Dongdong Chen, Lu Yuan, and Zicheng Liu. Dynamic relu. arXiv preprint arXiv:2003.10027, abs/2003.10027, 2020d. ",
+        "bbox": [
+            171,
+            304,
+            823,
+            333
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009. ",
+        "bbox": [
+            173,
+            342,
+            825,
+            385
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Emily L Denton, Wojciech Zaremba, Joan Bruna, Yann LeCun, and Rob Fergus. Exploiting linear structure within convolutional networks for efficient evaluation. In Advances in neural information processing systems, pp. 1269–1277, 2014. ",
+        "bbox": [
+            171,
+            393,
+            823,
+            436
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Ha, Andrew M. Dai, and Quoc V. Le. Hypernetworks. ICLR, 2017. ",
+        "bbox": [
+            174,
+            444,
+            660,
+            460
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kai Han, Yunhe Wang, Qi Tian, Jianyuan Guo, Chunjing Xu, and Chang Xu. Ghostnet: More features from cheap operations. In IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020. ",
+        "bbox": [
+            176,
+            468,
+            823,
+            511
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            563
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Howard, Mark Sandler, Grace Chu, Liang-Chieh Chen, Bo Chen, Mingxing Tan, Weijun Wang, Yukun Zhu, Ruoming Pang, Vijay Vasudevan, Quoc V. Le, and Hartwig Adam. Searching for mobilenetv3. CoRR, abs/1905.02244, 2019. URL http://arxiv.org/abs/1905. 02244. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            627
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017. ",
+        "bbox": [
+            173,
+            637,
+            825,
+            681
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jie Hu, Li Shen, and Gang Sun. Squeeze-and-excitation networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018. ",
+        "bbox": [
+            171,
+            689,
+            823,
+            718
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kevin Jarrett, Koray Kavukcuoglu, Marc’Aurelio Ranzato, and Yann LeCun. What is the best multistage architecture for object recognition? In The IEEE International Conference on Computer Vision (ICCV), 2009. ",
+        "bbox": [
+            174,
+            726,
+            823,
+            768
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yong-Deok Kim, Eunhyeok Park, Sungjoo Yoo, Taelim Choi, Lu Yang, and Dongjun Shin. Compression of deep convolutional neural networks for fast and low power mobile applications. arXiv preprint arXiv:1511.06530, 2015. ",
+        "bbox": [
+            174,
+            777,
+            823,
+            820
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jean Kossaifi, Antoine Toisoul, Adrian Bulat, Yannis Panagakis, Timothy M Hospedales, and Maja Pantic. Factorized higher-order cnns with an application to spatio-temporal emotion estimation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 6060–6069, 2020. ",
+        "bbox": [
+            173,
+            829,
+            825,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "L. D. Lathauwer, B. D. Moor, and J. Vandewalle. A multilinear singular value decomposition. In SIAM J. Matrix Anal. Appl, 2000. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vadim Lebedev, Yaroslav Ganin, Maksim Rakhuba, Ivan Oseledets, and Victor Lempitsky. Speeding-up convolutional neural networks using fine-tuned cp-decomposition. arXiv preprint arXiv:1412.6553, 2014. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiang Li, Wenhai Wang, Xiaolin Hu, and Jian Yang. Selective kernel networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2019. ",
+        "bbox": [
+            171,
+            155,
+            825,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ningning Ma, Xiangyu Zhang, Hai-Tao Zheng, and Jian Sun. Shufflenet v2: Practical guidelines for efficient cnn architecture design. In The European Conference on Computer Vision (ECCV), September 2018. ",
+        "bbox": [
+            173,
+            191,
+            823,
+            234
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ningning Ma, X. Zhang, J. Huang, and J. Sun. Weightnet: Revisiting the design space of weight networks. volume abs/2007.11823, 2020. ",
+        "bbox": [
+            169,
+            243,
+            825,
+            272
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vinod Nair and Geoffrey E. Hinton. Rectified linear units improve restricted boltzmann machines. In ICML, 2010. ",
+        "bbox": [
+            173,
+            281,
+            823,
+            310
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anh-Huy Phan, Konstantin Sobolev, Konstantin Sozykin, Dmitry Ermilov, Julia Gusak, Petr Tichavsky, Valeriy Glukhov, Ivan Oseledets, and Andrzej Cichocki. Stable low-rank tensor decomposition for compression of convolutional neural network. arXiv preprint arXiv:2008.05441, 2020. ",
+        "bbox": [
+            173,
+            319,
+            826,
+            375
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4510–4520, 2018. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            428
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(56):1929–1958, 2014. URL http://jmlr.org/papers/v15/ srivastava14a.html. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            492
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhuo Su, Linpu Fang, Wen xiong Kang, D. Hu, M. Pietikainen, and Li Liu. Dynamic group convo- ¨ lution for accelerating convolutional neural networks. In ECCV, August 2020. ",
+        "bbox": [
+            173,
+            501,
+            821,
+            530
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mingxing Tan and Quoc Le. Efficientnet: Rethinking model scaling for convolutional neural networks. In ICML, pp. 6105–6114, Long Beach, California, USA, 09–15 Jun 2019a. ",
+        "bbox": [
+            171,
+            539,
+            821,
+            568
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mingxing Tan and Quoc V. Le. Mixconv: Mixed depthwise convolutional kernels. In 30th British Machine Vision Conference 2019, 2019b. ",
+        "bbox": [
+            171,
+            575,
+            823,
+            606
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mingxing Tan, Ruoming Pang, and Quoc V. Le. Efficientdet: Scalable and efficient object detection. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020. ",
+        "bbox": [
+            173,
+            613,
+            823,
+            656
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhi Tian, Chunhua Shen, and Hao Chen. Conditional convolutions for instance segmentation. In ECCV, August 2020. ",
+        "bbox": [
+            171,
+            665,
+            823,
+            695
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Brandon Yang, Gabriel Bender, Quoc V. Le, and Jiquan Ngiam. Condconv: Conditionally parameterized convolutions for efficient inference. In NeurIPS, 2019. ",
+        "bbox": [
+            171,
+            703,
+            823,
+            733
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiahui Yu, Linjie Yang, Ning Xu, Jianchao Yang, and Thomas Huang. Slimmable neural networks. In International Conference on Learning Representations, 2019. URL https://openreview. net/forum?id ${ . } = { }$ H1gMCsAqY7. ",
+        "bbox": [
+            173,
+            739,
+            823,
+            784
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hongyi Zhang, Moustapha Cisse, Yann N. Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In International Conference on Learning Representations, 2018a. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ r1Ddp1-Rb. ",
+        "bbox": [
+            176,
+            791,
+            823,
+            835
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiangyu Zhang, Xinyu Zhou, Mengxiao Lin, and Jian Sun. Shufflenet: An extremely efficient convolutional neural network for mobile devices. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018b. ",
+        "bbox": [
+            174,
+            843,
+            823,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daquan Zhou, Qi-Bin Hou, Y. Chen, Jiashi Feng, and S. Yan. Rethinking bottleneck structure for efficient mobile network design. In ECCV, August 2020. ",
+        "bbox": [
+            173,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    }
+]

parse/train/eXlxB3aLOe/eXlxB3aLOe.md

@@ -0,0 +1,265 @@
+# GradInit: Learning to Initialize Neural Networks for Stable and Efficient Training
+
+Chen Zhu University of Maryland chenzhu@cs.umd.edu
+
+Renkun Ni University of Maryland rn9zm@cs.umd.edu
+
+Zheng Xu Google Research xuzheng@google.com
+
+Kezhi Kong University of Maryland kong@cs.umd.edu
+
+W. Ronny Huang Google Research wrh@google.com
+
+Tom Goldstein University of Maryland tomg@cs.umd.edu
+
+# Abstract
+
+Innovations in neural architectures have fostered significant breakthroughs in language modeling and computer vision. Unfortunately, novel architectures often result in challenging hyper-parameter choices and training instability if the network parameters are not properly initialized. A number of architecture-specific initialization schemes have been proposed, but these schemes are not always portable to new architectures. This paper presents GradInit, an automated and architecture agnostic method for initializing neural networks. GradInit is based on a simple heuristic; the norm of each network layer is adjusted so that a single step of SGD or Adam with prescribed hyperparameters results in the smallest possible loss value. This adjustment is done by introducing a scalar multiplier variable in front of each parameter block, and then optimizing these variables using a simple numerical scheme. GradInit accelerates the convergence and test performance of many convolutional architectures, both with or without skip connections, and even without normalization layers. It also improves the stability of the original Transformer architecture for machine translation, enabling training it without learning rate warmup using either Adam or SGD under a wide range of learning rates and momentum coefficients. Code is available at https://github.com/zhuchen03/gradinit.
+
+# 1 Introduction
+
+The initialization of network parameters has a strong impact on the training stability and performance of deep neural networks. Initializations that prevent gradient explosion/vanishing in back propagation played a key role in early successes with feed-forward networks [1, 2]. Even with cleverly designed initialization rules, complex models with many layers or multiple branches can still suffer from instability. For example, the original Transformer model [3] does not converge without learning rate warmup using the default initialization [4–6]; RoBERTa [7] and GPT-3 $\pmb { \| \widetilde { \ 8 } \| }$ have to tune the $\beta _ { 2 }$ parameter of Adam for stability when the batch size is large. Recent innovations have shown that architecture-specific initializations, which are carefully derived to maintain stability, can promote convergence without needing normalization layers [5, 9–12]. Unfortunately, the reliance on analytically derived initializations makes it difficult to realize the benefits of these methods when performing architecture search, training networks with branched or heterogeneous components, or proposing altogether new architectures.
+
+In this work, we propose a simple method for learning the initialization of a network with any architecture. Typically, initialization schemes draw parameters independently from a zero-mean distribution, with the variance of each distribution set to pre-determined values depending on the dimensions of the layers [1, 2]. Rather than deriving a closed-form expression for the these distribution parameters, our method re-scales each random weight tensor (e.g. convolution kernels) directly by a learned scalar coefficient. This small set of coefficients is optimized to make the first step of a stochastic optimizer (e.g. SGD or Adam) as effective as possible at minimizing the training loss, while preventing the initial gradient norm from exploding. In addition, this process is designed to take into account the direction, step size, and stochasticity of the optimizer. Finally, after the variance has been learned for each parameter tensor, the random network parameters are re-scaled and optimization proceeds as normal. We empirically find that our methods can make the initialization fall into a smooth loss region, reduce the inter-sample gradient variance, and accelerates training.
+
+Our proposed method, GradInit, is architecture agnostic, and works with both Adam and SGD optimizers. In the vision domain, we show it accelerates the convergence and test performance of a variety of deep architectures, from the vanilla feed-forward VGG net to ResNet, with or without Batch Normalization. It is efficient and scalable, finding good initializations using less than $1 \%$ of the total training time in our experiments, and it improves the initialization of ResNet-50 on ImageNet to obtain better final test accuracy. In the language domain, GradInit enables training the original Transformer model $\mathbb { \left[ 3 \right] }$ using either Adam or SGD without learning rate warmup for machine translation, which is commonly acknowledged to be difficult [4, 13]. As an extreme example of the capabilities of GradInit, we use it to initialize and train a 1202-layer ResNet that achieves significantly higher test accuracy than ResNet-110, which other initialization methods have failed to achieve.
+
+Finally, by visualizing the initial norms and gradient variances of the weights before and after GradInit is applied, we show that GradInit is a useful tool for identifying potential causes for instability at initialization, such as those imposed by normalization layers, and we summarize interesting scale patterns learned by GradInit that can be helpful for designing better initialization rules.
+
+# 2 Related Work
+
+Controlling the norms of network parameters at initialization has proven to be an effective approach for speeding up and stabilizing training. Glorot and Bengio $\mathbb { M }$ studied how the variance of features evolves with depth in feed-forward linear neural networks by assuming both activations and weight tensors are independent and identical random variables. They developed a technique in which the variance of each filter scales with its fan-in (the number of input neurons). This style of analysis was later generalized to the case of ReLU networks $\pmb { \mathbb { Z } } ] \mathbf { l }$ . These two analyses are most effective for feed-forward networks without skip connections or normalization layers. Based on the orthogonal initialization scheme $\pmb { \mathbb { I } }$ , Mishkin and Matas $\mathbb { \left. \boldsymbol { \cdot } \boldsymbol { \cdot } \right. }$ proposed an iterative procedure to rescale the orthogonally initialized weights of each layer in feedforward networks so that the activations of that layer have unit variance. However, this method fails to prevent the blowup of activations with depth for ResNets [16]. Recently, Gurbuzbalaban and Hu $\mathbb { \ m }$ proposed initialization schemes such that the network can provably preserve any given moment of order $s \in ( 0 , 2 ]$ for the output of each layer. The motivation is that the stochastic gradient updates can result in heavy-tailedness in the distribution of the network weights with a potentially infinite variance, but finite $s$ -order moment $\mathbb { \lVert 1 8 \rVert }$ . Again, these initialization schemes can only be applied for feed-forward neural networks.
+
+For more complex architectures, normalization layers $\mathbb { I m } \mathbb { Q } \mathbb { L O } \mathbb { I }$ and skip connections $\pmb { \mathbb { Z } } 1 \Vert$ stabilized training dynamics and improved the state-of-the-art. Similarly, learning rate warmup is a common trick for training large Transformers $\mathbb { \left[ 3 \right] }$ . These methods make training tractable for some models, but do not eliminate the high initial gradient variance that destabilizes training when the network is deep [9–11] or when the normalization layers are not carefully positioned [4].
+
+Several authors have proposed better initializations for networks with skip connections. This is often achieved by replacing the normalization layers with simpler scaling or bias operations, and scaling the weight matrices in each layer so that the variance of activations does not increase with depth [9– 12]. Similar analysis has been applied to self attention in Transformers [5]. Without removing the normalization layers, it is possbile to stabilize the initial parameter updates by introducing carefully initialized learnable scale factors to the skip connections $\pmb { \Vert 6 \Vert }$ or the residual branches $[ [ 2 2 ] ]$ . However, such techniques are often restricted to one specific architecture such as ResNets.
+
+Recently, Dauphin and Schoenholz $\boxed { \boxed { 1 6 } }$ proposed a task-agnostic and automatic initialization method, MetaInit, for any neural network achitecture. MetaInit optimized the norms of weight tensors to minimize the “gradient quotient”, which measures the effect of curvature near the initial parameters, on minibatches of random Gaussian samples. However, as training data is usually accessible for most tasks of interest, it is simpler and potentially more efficient to use the training data for initialization. MetaInit also involves the gradient of a Hessian-vector product that requires computing a “gradient of the gradient” multiple times in tandem, which is very computationally intensive. Our proposed method distinguishes itself from MetaInit in the following ways: (i) Our method is more computationally efficient. MetaInit involves computing third-order derivatives, results in long computing times and high memory usage. The memory overhead of MetaInit is more of an issue for networks with normalization layers. For the relatively small-scale CIFAR-10 problem with batch size 64, MetaInit requires three GPUs (RTX 2080Ti), while the proposed GradInit needs just one. (ii) Our method takes the stochasticity of minibatches into consideration. MetaInit uses the local curvature evaluated on a single minibatch, which fails to capture the variance of the loss/gradient between two different stochastic minibatches. (iii) Our method considers the training dynamics of different optimization algorithms including the learning rate and the direction of the gradient step, and effectively handles different optimizers including SGD and Adam.
+
+# 3 Method
+
+We aim to develop an initialization scheme applicable to arbitrary network architectures. Since previous works [1, 2, 9, 16, 10, 12] have shown that the initial weight norms effectively control the initial gradient norm on average, our method rescales the randomly initialized weight matrices using learnable scale factors.1
+
+Using a small number of gradient descent steps on these scale factors, the proposed GradInit method chooses the initialization scalars so that the loss after the first gradient step taken by a stochastic optimizer (SGD or Adam) is as low as possible. The process of learning initialization coefficients accounts for the chosen learning rate, optimizer, and other parameters. To prevent gradient explosion, our method enforces a constraint that the gradient norm is no larger than a constant $\gamma$ .
+
+Note that for scale-invariant weights, e.g., convolution kernels before BN layers, rescaling still changes their learning dynamics by changing their effective learning rate $\pm \overbrace { 1 2 3 } , \textcircled { 2 4 } ]$ . Empirically, GradInit goes beyond simply preventing exploding or vanishing gradients; it also reduces the gradient variance, making the initialization fall into a smooth loss region with small gradient variance so that training is fast, see discussion about Figure $\bigstar$ and comparisons in Figure $\bigtriangledown$
+
+# 3.1 Efficient Learning-based Initialization via Constrained Optimization
+
+We begin by filling all the weight matrices $\{ W _ { 1 } , \hdots , W _ { M } \}$ of the network with values drawn from independent zero-mean Gaussian distributions, except for the scales and biases of the normalization layers (if any), which are initialized to 1 and 0 respectively. During the initialization process, we keep $\{ W _ { 1 } , \hdots , W _ { M } \}$ constant, but we multiply each $W _ { i }$ with a learnable non-negative scale factor $\alpha _ { i }$ (initialized to 1). After initialization, we rescale the weights by the learned scale factors, and start training without the learnable scale factors just as normal. We use $\pmb { m } = \{ \alpha _ { 1 } , . . . , \alpha _ { M } \}$ to denote the set of scale factors, and $\pmb { \theta } _ { m } = \{ \alpha _ { 1 } \pmb { W } _ { 1 } , \ldots , \alpha _ { M } \pmb { W } _ { M } \}$ is the set of rescaled weight matrices.
+
+Let $\begin{array} { r } { L ( S ; \pmb { \theta } ) = \frac { 1 } { | S | } \sum _ { x \in S } \ell ( x ; \pmb { \theta } ) } \end{array}$ be the average loss of the model parameterized by $\pmb \theta$ on a minibatch of samples $S$ , where $| S |$ is the number of samples in the minibatch. We use $\pmb { g } _ { S , \pmb { \theta } } = \nabla _ { \pmb { \theta } } L ( S ; \pmb { \theta } )$ as a shorthand for the gradient of $\pmb { \theta }$ . During standard training, this gradient is preprocessed/preconditioned by the optimization algorithm $\mathcal { A }$ , and then used to update the network parameters. GradInit solves the following constrained optimization problem:
+
+$$
+\begin{array} { r l } { \underset { m } { \mathrm { m i n i m i z e } } } & { L ( \tilde { S } ; \pmb { \theta } _ { m } - \eta \mathcal { A } [ \pmb { g } _ { S , \pmb { \theta } _ { m } } ] ) , } \\ { \mathrm { s u b j e c t ~ t o ~ } } & { \| \pmb { g } _ { S , \pmb { \theta } _ { m } } \| _ { p , s } \le \gamma , } \end{array}
+$$
+
+where $S$ and $\tilde { S }$ are two different minibatches, $\eta$ is a prescribed learning rate for the optimization algorithm $\mathcal { A }$ , $p _ { \mathcal { A } }$ is the $\ell _ { p }$ -norm associated with $\mathcal { A }$ , and $\gamma$ is the upper bound for the norm. For the first gradient step, Adam uses $\mathcal { A } [ g _ { S , \theta _ { m } } ] = \mathrm { s i g n } ( g _ { S , \theta _ { m } } ) \left[ \left[ 2 5 \right] \right]$ , while SGD uses $\mathcal { A } [ g ( S ; \theta _ { m } ) ] =$
+
+$\gamma \pmb { g } ( S ; \pmb { \theta } _ { m } ) / \| \pmb { g } ( S ; \pmb { \theta } _ { m } ) \| _ { 2 }$ . We show how to choose $\gamma$ and $p _ { \cal A }$ without tuning in Section 3.3. We discuss the formulation of this problem and how to solve it below.
+
+# 3.2 Solving the Constrained Problem
+
+The problem $( 1 )$ is solved using a stochastic gradient descent method in which we sample new mini-batches on each iteration. Since the proposed method uses gradient updates to compute the initialization, we dub it GradInit. We propose a simple solver to optimize objective $( 1 )$ in Algorithm 1 A key feature of our method is that is makes a simple approximation: after $g _ { S , \theta _ { m } }$ is computed on the forward pass of an iteration, we treat $\mathcal { A } [ \pmb { g } _ { S } , \pmb { \theta } _ { m } ]$ as a constant and do not back-propagate through $\mathcal { A } [ \pmb { g } _ { S } , \pmb { \theta } _ { m } ]$ on the backward pass. We make this choice to keep computing costs low, and because it is not possible to back-propagate through the non-differentiable sign function for Adam.
+
+Algorithm 1 GradInit for learning the initialization of neural networks.   
+
+<table><tr><td></td><td>1: Input: Target optimization algorithm Aand learning raten for model training, initial model parameters 0o, learningrateTof the GradInit scales m,total iterations T,upper boundof the gradienty,lower bound for</td><td></td></tr><tr><td>2:mi←1</td><td>the initialization scalars α= O.01.</td><td></td></tr><tr><td></td><td>3: for t = 1 to T do</td><td></td></tr><tr><td>4:</td><td>Sample St from training set.</td><td></td></tr><tr><td>5:</td><td>Lt←S l(xk;0mt)，gt←VθLt</td><td></td></tr><tr><td>6:</td><td>if |lgtllpA &gt;γ then</td><td></td></tr><tr><td>7:</td><td>mt+1 ← mt -TVmtllgtllpA</td><td></td></tr><tr><td>8:</td><td>else</td><td></td></tr><tr><td>9:</td><td>Sample St from training set.</td><td></td></tr><tr><td>10:</td><td>Lt+1←s∑x∈ste(xk;Omt-nAlgt]）</td><td></td></tr><tr><td>11: 12:</td><td>mt+1←mt-TVmtLt+1</td><td></td></tr></table>
+
+To enforce the constraint in $( 1 )$ , we test whether the constraint is satisfied after computing $\pmb { g } ( S ; \pmb { \theta } _ { m } )$ . If not, we take a gradient descent step to minimize $\| \pmb { g } ( S ; \pmb { \theta } _ { m } ) \| _ { p _ { A } }$ , which involves computing second A order derivatives. If the constraint is satisfied, then we instead compute a gradient descent step for the loss. In addition, we set a lower bound $\underline { { \alpha } } = 0 . 0 1$ for all $\alpha _ { i }$ . We find that this prevents scalars from landing on small values during minimization and keeps the GradInit optimizer stable. In our experiments, we find the only layer that ever hit this lower bound is the final FC layer on some networks (see the figures in Section $4 . 1 )$ . We find this procedure converges reliably within 2000 iterations for ImageNet, and fewer than 400 iterations for CIFAR-10, taking less than $1 \%$ of the total training time on both problems. We also find it works well to set the step size $\tau$ to values within the range between $1 0 ^ { - 3 }$ and $1 0 ^ { - 1 }$ . During initialization, the gradient norm constraint is satisfied for the majority of iterations. The choice of $\gamma , p _ { \mathcal { A } }$ will be discussed in Section $\underline { { \boldsymbol { \left. 3 . 3 \right. } } }$
+
+Stochasticity of mini-batching. The objective in $( 1 )$ uses two different mini-batches; $S$ is used to compute the gradient, and $\tilde { S }$ is used to compute the loss. Ideally, $S$ and $\tilde { S }$ should be independently sampled from the training set to capture the randomness of the stochastic optimizer. However, when the network has large initial gradient variance, the gradients on $S$ and $\tilde { S }$ usually differ a lot, and for $\tilde { S }$ , the gradient update step $\theta _ { m } - \eta \mathcal { A } \left[ g _ { S , \theta _ { m } } \right]$ becomes more similar to adding random perturbations to the parameters. We find our objective less effective at accelerating convergence in this case, as shown by the first-epoch accuracy $( A c c _ { 1 } )$ in Table $^ { 1 . }$ On the other hand, the randomness is not captured if $S = \tilde { S }$ , and we find empirically that $\theta _ { m }$ can exploit the loss by increasing the gradient norm and destabilize training in this case (see Table $\textcircled{8}$ . Without excessive tuning, we find that we get more reliable behavior for different architectures when $\tilde { S }$ is a mixture of $50 \%$ samples from $S$ and $50 \%$ re-sampled training data, and use this setting by default unless otherwise stated.
+
+Table 1: Accuracies on CIFAR-10 using different overlapping ratios of $\tilde { S }$ and $S$ for GradInit.   
+
+<table><tr><td>Model</td><td>Sns |S]</td><td>Acc1</td><td>AcCbest</td></tr><tr><td>VGG-19</td><td>0</td><td>21.9 ± 4.4</td><td>94.5 ± 0.1</td></tr><tr><td>w/o BN</td><td>0.5</td><td>29.3 ± 0.6</td><td>94.7± 0.02</td></tr><tr><td>(20.03 M)</td><td>1</td><td>28.7 ± 1.0</td><td>94.5 ± 0.1</td></tr></table>
+
+# 3.3 Setting and Enforcing the Constraint
+
+The constraint in $\mathbb { \underline { { ( 1 ) } } }$ is included to prevent the network from minimizing the loss in a trivial way by blowing up the initial gradient. In other words, we want the optimizer to achieve small loss by choosing an effective search direction rather than by taking an extremely large step in a sub-optimal direction.
+
+Setting $p _ { \cal A }$ and $\gamma$ through first-order approximation. We show that $p _ { \mathcal { A } }$ and $\gamma$ can be set easily with a rule of thumb and without a parameter search. From the first-order approximation, we expect the first gradient step to result in a change in the loss on $S$ as following:
+
+$$
+L ( S ; \theta _ { m } - \eta \mathcal { A } [ g _ { S , \theta _ { m } } ] ) - L ( S ; \theta _ { m } ) \approx - \eta \mathcal { A } [ g _ { S , \theta _ { m } } ] ^ { T } g _ { S , \theta _ { m } } = \left\{ \begin{array} { l l } { - \eta \| g _ { S , \theta _ { m } } \| _ { 2 } ^ { 2 } , } & { \mathrm { i f ~ } \mathcal { A } \mathrm { ~ i s ~ S G D } , } \\ { - \eta \| g _ { S , \theta _ { m } } \| _ { 1 } , } & { \mathrm { i f ~ } \mathcal { A } \mathrm { ~ i s ~ A d a m } . } \end{array} \right.
+$$
+
+To effectively bound the approximated change in Eq. $^ { 2 , }$ we choose $\ell _ { p _ { A } }$ to be the $\ell _ { 2 }$ and $\ell _ { 1 }$ norm for ASGD and Adam respectively, so when the constraint is satisifed, the maximum change in the loss, according to our local approximation, is $\eta \gamma ^ { 2 }$ for SGD and $\eta \gamma$ for Adam. We recommend setting $\gamma$ such that $\eta \gamma ^ { 2 } = 0 . 1$ for SGD and $\eta \gamma = 0 . 1$ for Adam. According to the linear approximations, this limits the gradient magnitude so that the first step of SGD can decrease the loss by at most 0.1. This simple rule was used across all vision and language experiments.
+
+Why a constraint and not a penalty? Instead of formulating GradInit as a constrained optimization, one can alternatively formulate it as minimizing the objective with a gradient penalty: minimize $L ( \tilde { S } ; \theta _ { m } - \eta A \left[ \pmb { g } _ { S , \theta _ { m } } \right] ) + \lambda \Vert \pmb { g } _ { S ; \theta _ { m } } \Vert _ { p _ { A } }$ , where $\lambda > 0$ is the penalty strength.
+
+The penalized objective has two drawbacks compared to the constrained one in Eq. $^ { 1 . }$ First, every gradient descent step on the penalized objective involves second-order gradients due to the gradient regularization, while the constrained form does not need second-order gradients when the constraint is satisfied. Second, it is difficult to choose a good $\lambda$ that works well for all architectures. By contrast, we set $\gamma$ by analyzing the first-order approximation mentioned above, and find the same $\gamma$ works well for different architectures. The results supporting these two points are given in Table 2.
+
+Table 2: Time cost and accuracy (average of 4 runs) for running one epoch of regularization/constrained form of GradInit.   
+
+<table><tr><td>Model</td><td>VGG-19 w/o BN</td><td>VGG-19 W/BN</td><td>ResNet-110 ResNet-110 w/o BN w/BN</td></tr><tr><td>Time (s)</td><td>82 vs.56</td><td>100 vs. 62</td><td>169 vs.103 269vs.195</td></tr><tr><td>入=10-4</td><td>32.3,94.6</td><td>10.6,93.1</td><td>33.7,93.9 32.4,95.2</td></tr><tr><td>入=10-2</td><td>30.4,94.5</td><td>10.4,93.0</td><td>36.7,94.1 32.6,95.3</td></tr><tr><td>入=1</td><td>18.2, 74.7</td><td>38.5,95.1</td><td>30.7,94.2 36.5,95.3</td></tr><tr><td>γ=1</td><td>29.3,94.7</td><td>47.8, 95.1</td><td>36.2,94.6 38.2, 95.4</td></tr></table>
+
+# 4 Experiments
+
+We evaluate GradInit on benchmark datasets for image classification and machine translation tasks. For image classification, five different architectures are evaluated for CIFAR10 [26], and ResNet-50 is evaluated for ImageNet [27]. For machine translation, we use GradInit to find good initializations for a Post-LN Transformer without any change to its original architecture on IWSLT-14 De-En [28]. We observe that the method can remove the necessity of any form of learning rate warmup for both Adam and SGD.
+
+We conduct our experiments in PyTorch. We use the fairseq library for machine translation $\left[ \left[ 2 9 \right] \right]$ . All the experiments on CIFAR-10 and IWSLT-14 DE-EN can run with one single NVIDIA RTX 2080 Ti GPU with 11GB of RAM.
+
+GradInit first initializes the weights using Kaiming initialization [2] for all the Conv and FC layers for image classification. For machine translation, we use the default Xavier initialization [1]. We optimize the scale factors $\left\{ \alpha _ { i } \right\}$ with Adam $\pmb { \mathbb { B } } 0 \|$ using the default momentum parameters.
+
+# 4.1 Image Datasets with Various Architectures
+
+The introduction of Batch Normalization (BN) $\mathbb { \lVert 1 9 \rVert }$ and skip connections makes it relatively easy to train common CNNs for image classification to achieve high accuracy. Despite this, we show that
+
+when the network is very deep, the network is unstable even when both BN and skip connections are used, and GradInit can significantly improve the stability. The results on CIFAR-10 are given in Table 3 and results on ImageNet are given in Table 6.
+
+# 4.1.1 Settings
+
+Architectures. On CIFAR-10, we focus on the feedforward VGG net and the prevalent and powerful ResNet, with and without BN layers. For networks without BN, we use learnable biases in all layers. For ResNet, we additionally evaluate a deep 1202-layer version. We give results for other architectures (Wide ResNet, DenseNet) in Appendix E due to space limits. We compare with four different methods/settings: 1) Kaiming Initialization [2]; 2) First train the network for one epoch with a constant learning rate equal to the starting learning rate, labelled as $^ { 6 } { + } 1$ epoch (Const. LR)" in Table 3; 3) First train the network for one epoch with a linear warmup learning rate, labbeled as $^ { 6 6 } { + 1 }$ epoch (Warmup)" in Table 3; 4) MetaInit [16].
+
+On ImageNet, we use the ResNet-50 model $\mathbb { \left| \mathbb { Z } \right\| }$ . We compare with Kaiming Initialization, FixUp initialization $[ [ 9 $ and MetaInit. For the ResNet-50 without BN, we follow the architecture of FixUp for fair comparisons, but we still use the original Kaiming initialization as the starting point of GradInit.
+
+Hyperparameters. We set $\mathcal { A }$ to SGD and $\eta = 0 . 1$ (the same as the base learning rate) for GradInit in all image classification experiments. On CIFAR-10, we train networks with a batch size of 128. We find MetaInit often takes 2 to 3 times as much memory as GradInit. We run GradInit or MetaInit for one epoch on the data, which takes less than $1 \%$ of the total training time. For GradInit, according to our analysis in Section $^ { 3 . 3 , }$ we fix the gradient norm constraint $\gamma = 1$ in all these experiments. Therefore, as in MetaInit, the only hyperparameter that needs to be tuned is the learning rate $\tau$ of the scale factors. We do a grid search on $\tau$ in the range $[ 1 0 ^ { - 3 } , 1 0 ^ { - 1 } ]$ , and report the results with the best average final test accuracy on 4 runs. After GradInit initialization, we use a learning rate of 0.1 and the cosine annealing learning rate schedule without restart $\textcircled { \scriptsize { 1 3 1 } }$ to train the model for 200 epochs, where the learning rate decays after each iteration and decays to 0 in the last iteration. Due to their high initial gradient variance (see Figure $^ { 6 ) }$ , we have applied gradient clipping (maximum norm is 1) to all non-BN networks so that they converge without GradInit under the same schedule.
+
+On ImageNet, we train the ResNet-50 model for 90 epochs with a total batch size of 256 on 4 GPUs. Due to the difference in the library for training and the number of GPUs used, which affects the BN statistics, our baseline top-1 accuracy of ResNet-50 (w/ BN) on ImageNet is $0 . 7 9 \%$ lower than $\pmb { \mathbb { B 2 } }$ . We use SGD with a starting learning rate of 0.1 and decay the learning rate by 10 after the $3 0 \mathrm { t h }$ and 60th epoch. We provide additional details in Appendix A.
+
+# 4.1.2 Results and Analysis
+
+Table 3: First epoch $( A c c _ { 1 } )$ and best test accuracy over all epochs $( A c c _ { b e s t } )$ for models on CIFAR-10. We report the mean and standard error of the test accuracies in 4 experiments with different random seeds. Best results in each group are in bold.   
+
+<table><tr><td colspan="2">Model (#Params)</td><td>VGG-19 w/o BN (20.03M)</td><td>VGG-19 w/BN (20.04M)</td><td>ResNet-110 w/o BN (1.72M)</td><td>ResNet-110 w/BN (1.73M)</td><td>ResNet-1202 w/BN (19.42M)</td></tr><tr><td rowspan="2">Kaiming</td><td>AcC1</td><td>29.1 ± 1.5</td><td>12.6 ± 0.6</td><td>16.1 ± 2.1</td><td>23.2 ± 0.9</td><td>12.9 ± 2.8</td></tr><tr><td>AcCbest</td><td>94.5 ± 0.1</td><td>94.4 ± 0.1</td><td>94.2 ± 0.1</td><td>95.0± 0.2</td><td>94.4 ± 0.6</td></tr><tr><td rowspan="2">+1 epoch (Const. LR)</td><td>Acc1</td><td>37.2 ± 1.1</td><td>19.6 ± 4.0</td><td>21.0 ± 3.8</td><td>32.5 ±3.8</td><td>12.6 ± 2.8</td></tr><tr><td>Accbest</td><td>94.4± 0.1</td><td>94.5 ± 0.1</td><td>93.9 ± 0.4</td><td>94.7 ± 0.3</td><td>94.0 ± 0.4</td></tr><tr><td rowspan="2">+1 epoch (Warmup)</td><td>Acc1</td><td>37.4 ±1.2</td><td>53.5 ± 2.9</td><td>19.8 ± 0.5</td><td>48.7 ± 1.1</td><td>28.1 ± 1.3</td></tr><tr><td>AcCbest</td><td>94.4 ± 0.1</td><td>94.7 ± 0.1</td><td>94.1 ± 0.1</td><td>95.1 ± 0.1</td><td>95.4± 0.2</td></tr><tr><td rowspan="2">MetaInit</td><td>AcC1</td><td>30.5± 0.9</td><td>35.1 ± 0.6</td><td>14.6 ± 2.2</td><td>29.0 ± 1.5</td><td>11.7 ± 1.6</td></tr><tr><td>AcCbest</td><td>94.6 ± 0.1</td><td>94.6 ± 0.1</td><td>94.2 ± 0.1</td><td>94.8 ± 0.1</td><td>95.0 ± 0.5</td></tr><tr><td rowspan="2">GradInit</td><td>AcC1</td><td>29.3±0.6</td><td>47.8 ± 1.8</td><td>36.2 ±0.8</td><td>38.2 ± 0.9</td><td>29.0 ± 1.1</td></tr><tr><td>Accbest</td><td>94.7 ± 0.1</td><td>95.1 ± 0.1</td><td>94.6 ± 0.1</td><td>95.4± 0.1</td><td>96.2 ± 0.1</td></tr></table>
+
+GradInit further stabilizes feedforward nets with BN. BN does stabilize VGG-19 and allows training without gradient clipping, but with an average first-epoch test accuracy of only 12.57 and an average final test accuracy lower than the version without BN (see Table $3 )$ , it does not seem to eliminate the instability of Kaiming initialization. As shown in Figure $\bigtriangledown ,$ its initial gradient variance is still relatively high compared with GradInit. BN could magnify the gradient variance when the variance of its input features (in the forward pass) is smaller than 1 (see Appendix $\boxed { \mathbf { C } }$ . GradInit reduces the gradient variance by 4 orders of magnitude compared to Kaiming initialization , resulting in significantly higher test accuracy after the first epoch $( 4 7 . 7 9 \%$ vs. $1 2 . 5 7 \%$ ), which also has an impact on the final test accuracy $( 9 5 . 1 3 \%$ vs. $9 4 . 4 1 \%$ ). The reduction in gradient variance is achieved mainly by scaling down the weights of the final FC layer and the last 2 BN layers, so that the variance of the activations is reduced in the forward pass. This learned behavior is consistent with the strategy of FixUp, where the final FC layer is initialized to 0. Another source of gradient variance reduction is achieved by increasing the weight norms of the remaining Conv and BN layers, so that the variance of the inputs to the BN layers is increased and the gradient magnifying effect of BN is alleviated in the backward pass. This reduced the ratio $\sigma ( \pmb { g } _ { 1 } ) / \bar { \sigma } ( \pmb { g } _ { 1 6 } )$ from 204.9 to 164.8 for the Conv layers in Figure 4. By contrast, FixUp only reduces the weight norms, which may not always be the best solution for networks with normalization layers.
+
+![](images/b1c7d4d91bac8e66a991e0f50cbde8c33271da8b1f33abfd97bece26ad451b27.jpg)  
+Figure 1: Top row: results of ResNet-110 on CIFAR-10. Bottom row: results of ResNet-50 on ImageNet. Left two columns: compare the relative cross-batch gradient variance on the training set for the BN and Conv/FC layers before and after GradInit. Right two columns: weight norms before and after GradInit. Ratio between points in the same layer reflects the scale factor. Note each of the residual blocks has 2 and 3 Conv and BN layers for the ResNet-110 and ResNet-50, respectively. The initial relative gradient variance are reduced for all layers except the final linear layer in both settings. The strategies are similar on two different datasets. Within each residual block, the last BN layer has the smallest scaling factors, and the scales of all Conv layers are surprisingly increased. Best viewed in color.
+
+![](images/68982e2c5ddf39fc5a9aa28acb3eeeb208468a65c714c3beb3e000e0d69d317f.jpg)  
+Figure 2: Comparing the convergence of Kaiming Initialization and GradInit on CIFAR-10, for models trained with SGD (left three) and Adam (right).
+
+Deep residual networks still need better initializations. We also gain significant improvements from GradInit for ResNet-110 and ResNet-1202. In ResNets, the skip connections cause the variance of activations to accumulate as the ResNet goes deeper, even for the version with BN $\mathbb { m }$ . This issue is more significant when the ResNet scales to 1202 layers, from which we can see that with Kaiming initialization, the first-epoch accuracy of ResNet-1202 is quite low, and the final test accuracy is even worse than the shallower ResNet-110, matching the observations of He et al. $\pmb { \mathbb { D } } \mathbf { 1 } \mathbf { h }$ . Warmup is even more effective than MetaInit at accelerating the convergence and improving the final test accuracy of ResNet-1202, but GradInit still outperforms its final test accuracy by $0 . 8 \%$ , and the resulting ResNet-1202 finally achieved higher accuracy than ResNet-110.
+
+The learned layer-wise rescaling patterns of GradInit are even more interesting for ResNets with BN. For ResNets with BN, recall that we have two Conv layers and two BN layers in each residual block. As shown in Figure 1, GradInit learns to increase the weight norms of all the linear layers except for the final FC layer, instead of decreasing as for the case without BN (see Figure $6 )$ . A more unique pattern is the collaborative behavior of the BN weights, where the second BN in each residual block is usually scaled down while the first BN is always scaled up. In deeper layers, the joint effect of these two BN weights is to downscale the activations and reduce their variance in the forward pass, with a more significant reducing effect as the layers get deeper. Intuitively, the marginal utility of adding a new layer decreases with depth. Therefore, for deeper layers, GradInit learns to further downscale the residual branch, and prevents the variance from increasing too much in the forward pass. Inside each residual block, increasing the scale factors of the first BN helps to reduce the magnification effect of the second BN on the gradient; forcing the input activations to the second convolution to have variance larger than 1 ensures its variance after the following convolution layer does not go below 1, avoiding the magnification effect that the second BN has on the gradient variance. See Appendix C for more discussions about the magnifying effect.
+
+Table 4: Comparing the results of GradInit with fixed BN scale parameters (Fix BN) and only rescale the BN parameters (Only BN).   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">Kaiming</td><td colspan="2">GradInit</td><td colspan="2">GradInit (Fix BN)</td><td rowspan="2">GradInit (Only BN) Accbest</td></tr><tr><td>Acco</td><td>Accbest</td><td>Acco</td><td>Accbest</td><td>Acco Accbest</td><td>Acco</td></tr><tr><td>VGG-19 (w/ BN)</td><td>12.6 ±0.6 94.4 ± 0.1 47.8 ± 1.8 95.1 ± 0.1 13.1 ± 0.9 94.6 ±0.1 14.4 ± 2.1 94.4 ± 0.1</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>ResNet-110(w/BN) 23.2±0.9 95.0 ±0.2 38.2 ±0.9 95.4 ± 0.1 24.7±3.1 94.7±0.3 25.4±3.1 94.6± 0.3</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+Table 5: Comparing the results with multiplying each weight matrix with a learnable scaler (Learning Scalars) on CIFAR10. The VGG-19 model is not able to converge unless we reduce the initial learning rate to 0.01, which obtained worse final accuracy. The ResNet-110 model’s $A c c _ { 0 }$ was $10 \%$ for 2 of the 4 runs.   
+
+<table><tr><td>Model</td><td colspan="2">Learning Scalars</td><td colspan="2">GradInit</td></tr><tr><td></td><td>Acco</td><td>Accbest</td><td>Acco</td><td>AcCbest</td></tr><tr><td>VGG-19 (w/BN,Ir=0.1)</td><td>10.0±0.0</td><td></td><td>10.0±0.0 47.8±1.8 95.1±0.1</td><td></td></tr><tr><td>VGG-19 (w/BN,Ir=0.01) 50.6±0.8</td><td></td><td>93.4 ±0.1</td><td></td><td>=</td></tr><tr><td>ResNet-110 (w/BN)</td><td>21.5 ± 6.9</td><td></td><td>94.7 ± 0.1 38.2 ± 0.9 95.4 ± 0.1</td><td></td></tr></table>
+
+Generalizing to Adam. Models in previous experiments are trained with SGD. We also consider the case when $\mathcal { A }$ is Adam and use AdamW $\mathbb { \lVert 3 3 \rVert }$ to train the ResNet-110 (w/ BN) model on CIFAR-10. Following $\pmb { \mathbb { B 4 } }$ , we use a cosine annealing learning rate schedule with initial learning rate $3 \times 1 0 ^ { - 3 }$ and weight decay 0.2. For GradInit, we set $\gamma = 2 5$ . The $A c c _ { 1 }$ and $A c c _ { b e s t }$ of Kaiming initialization and GradInit are $( 3 6 . 6 \pm 4 . 7$ , $9 4 . 9 \pm 0 . 1 )$ and $( 4 0 . 2 \pm 0 . 2$ , $9 5 . 3 \pm 0 . 1 )$ , respectively. We also show the per-epoch test accuracy in Figure 2.
+
+The importance of rescaling BN layers. The scale parameters of BN layers usually controls the variance of activations and gradients in the forward and backward passes, while the linear layers right before the BN layers are scale-invariant. Although changing the magnitudes of the scale-invariant layers affect their learning dynamics $\mathbb { \left| \sum 3 \right| \left| \sum 4 \right| }$ , we find it important for GradInit to rescale both BN and other linear layers, as shown in Table 4.
+
+The importance of GradInit’s objective. GradInit is designed to rescale the layers to solve the constrained optimization problem in Eq. $^ { 1 . }$ Simply letting the model to learn to rescale the layers cannot improve the results, and sometimes further causes instability, as shown in Table $5 .$ We hypothesize that the bad results with VGG are due to a mismatch between the scales/norms of the gradients of the scalars and the weights. To make this alternative work, we may need to set different learning rates for the scalars and the weights, which adds to the difficulty of hyperparameter tuning. Note we do not learn the scalars when training networks initialized by GradInit.
+
+Table 6: $A c c _ { 1 } / A c c _ { b e s t }$ of ResNet-50 models on ImageNet. Result of MetaInit comes from Dauphin and Schoenholz $[ [ 1 6 ] ]$ and we reimplemented the rest.   
+
+<table><tr><td></td><td>Kaiming</td><td>FixUp</td><td>MetaInit</td><td>GradInit</td></tr><tr><td>w/BN</td><td>14.6/75.9</td><td>1</td><td>-</td><td>19.2/76.2</td></tr><tr><td>w/o BN</td><td>1</td><td>18.0/75.7</td><td>-/75.4</td><td>19.2/75.8</td></tr></table>
+
+GradInit scales to ImageNet. As shown in Table $6 ,$ GradInit also accelerates convergence and improves test accuracy of ResNet-50 on ImageNet, with or without BN layers, despite having to use a smaller batch size for GradInit than training due to our GPU memory limit. The acceleration achieved by GradInit is even more significant than FixUp, even on the network with the architecture designed for the initialization.
+
+# 4.2 Training the Original Transformer Model without Warmup
+
+For a Transformer model to converge, either an explicit or implicit learning rate warmup stage is needed, especially for the original Transformer architecture. It is observed that this Post-LN architecture tends to outperform the Pre-LN model $\textcircled { 6 }$ while having higher gradient variance at initialization [4]. Is it believed that this high variance makes a warmup stage inevitable. Previous works that removes the warmup stage often involves architectural changes, e.g., removing Layer Normalizations, since it can surprisingly cause instability [4]. Here, we show that with a proper initialization, we can do away with the warmup stage for the original Post-LN Transformer without any modification to the architecture. Table 7 summarizes the architectural changes and best results of methods for improving the initialization of Post-LN Transformers. We compare the stability of the GradInit and Admin initialization methods without warmup in Figure 3.
+
+Table 7: A comparison of GradInit with with the results from the papers (top 4 rows), and our reimplementation of Admin for training the Post-LN Transformer model on the IWSLT-14 De-EN dataset. “Standard" refers to training with standard initialization and warmup.   
+
+<table><tr><td>Method</td><td>Remove LN</td><td>Wskip</td><td>Warmup</td><td>Optimizer</td><td>BLEU</td></tr><tr><td>Standard [6</td><td></td><td></td><td>√</td><td>RAdam</td><td>35.6</td></tr><tr><td>FixUp 回</td><td>√</td><td></td><td>√</td><td>Adam</td><td>34.5</td></tr><tr><td>T-FixUp[5]</td><td></td><td></td><td></td><td>Adam</td><td>35.5</td></tr><tr><td>Admin 回</td><td></td><td>√</td><td></td><td>RAdam</td><td>35.7</td></tr><tr><td>Admin</td><td></td><td>√</td><td></td><td>Adam</td><td>36.1</td></tr><tr><td>Admin</td><td></td><td>√</td><td></td><td>SGD</td><td>33.7</td></tr><tr><td>GradInit</td><td></td><td>√</td><td></td><td>Adam</td><td>36.0</td></tr><tr><td>GradInit</td><td></td><td></td><td></td><td>Adam</td><td>36.1</td></tr><tr><td>GradInit</td><td></td><td></td><td></td><td>SGD</td><td>35.6</td></tr></table>
+
+# Dataset, Architecture, & Hyperparameters.
+
+IWSLT’14 DE-EN $\pmb {  \pmb {   2 8  }  }$ is a German to English translation dataset that has $1 6 0 \mathrm { k }$ training examples. Our Transformer model is inherited from $\mathbf { \widehat { \mathbb { B } } }$ , which is a Post-LN Transformer placing its Layer Normalization after the summation of the skip connection and the residual branch. It has a 512- dimensional word embedding layer and 1024 dimensions in its hidden FFN layer. We also apply GradInit to the variant from Admin $\textcircled { 6 }$ , where a learnable vector ${ { \pmb w } _ { s k i p } }$ is element-wise multiplied with each dimension of the skip connection, but we initialize it to 1 for GradInit. Please refer to $\dot { \left. \left[ 6 \right] \right. }$ for how Admin initializes these weights. Following $\textcircled { 6 }$ , we use a linearly decaying learning rate schedule that decays from the maximum learning rate $\eta _ { \mathrm { m a x } }$ to 0 as the model trains for 100K iterations. For training with SGD, we set the prescribed learning rate $\eta _ { \mathrm { m a x } } = 0 . 1 5$ , and use $\eta = 0 . 1 5 , \gamma = 1$ for GradInit. We do a grid search on $\eta _ { \mathrm { m a x } }$ for Admin and report its best result in Table $\perp$ For training with Adam, we set $\dot { \eta } = 5 \times 1 0 ^ { - 4 } , \dot { \gamma } = 1 0 ^ { 3 }$ for the objective of GradInit, so that $\eta \gamma$ is $O ( 1 0 ^ { - 1 } )$ as discussed in Section 3.3. We train the initialized model $\eta _ { \mathrm { m a x } }$ and $\beta _ { 2 }$ as listed in Figure $3 .$ We evaluate the BLEU score every epoch, and report the best BLEU scores throughout training for each run. For GradInit, we set the maximum number of iterations $T$ to 780. By comparison, the warmup stage usually takes 4000 iterations, and we find that if we use 780 steps for warmup, the model does not converge with $\eta _ { \mathrm { m a x } } \ge 3 \times 1 0 ^ { - 4 }$ . For $\eta _ { \mathrm { m a x } } = 2 \times 1 0 ^ { - 4 }$ with 780-step warmup, the BLEU score is 35.4, worse than GradInit’s 36.0, showing the advantage of GradInit against warmup.
+
+Stability after removing warmup for Adam. In Figure $\boxed { 3 }$ , the training process becomes more unstable as $\beta _ { 2 }$ grows larger. From the analysis of RAdam $[ \overbrace { 3 5 } ] ]$ , this is because the variance of the gradient has a stronger impact on the adaptive learning rate when $\beta _ { 2 }$ is closer to 1. Therefore, the largest $\beta _ { 2 } < 1$ that maintains the performance of the trained model reflects the stability of the initialization. We can see GradInit results in more stable models than Admin in general, though their best performance numbers are almost the same. In addition, we find ${ { \pmb w } _ { s k i p } }$ can help stabilize training in extreme hyper parameter settings, e.g., at $\eta _ { \mathrm { m a x } } = 5 \times 1 0 ^ { - 4 }$ and $\beta _ { 2 } = 0 . 9 9 5$ in Figure $\bigtriangledown _ { \ b { \lambda } }$ GradInit with ${ { \pmb w } _ { s k i p } }$ obtains a good average BLEU score of 36.0, while without ${ { \pmb w } _ { s k i p } }$ only succeeded in obtaining a BLEU score $> 3 5$ for one out of four experiments, resulting in an average BLEU score of 8.9.
+
+We also find the network is unable to be trained without learning rate warmup if we just fix ${ { \pmb w } _ { s k i p } }$ to its initial value given by Admin and leave the initialization of other parameters unchanged. Nevertheless, with GradInit, we do not need to modify the architecture of Post-LN Transformer to obtain the same good result as Admin. For a closer look at the stabilization mechanism, we show the weight norms and gradient variance at initialization of the original Post-LN architecture using GradInit and Xavier initialization in Figure 9 of the Appendix. For Xavier initialization, the gradient variance is relatively higher for all encoder layers, so GradInit downscales the encoder layer weights more in general. For the LN weights, GradInit only
+
+![](images/54b16b400c864897eac4effa71200cc1009e90a3c1eecd924677164f4aecc148.jpg)  
+Figure 3: BLEU scores for the Post-LN Transformer without learning rate warmup using Adam on IWSLT-14 DE-EN under different learning rates $\eta _ { \mathrm { m a x } }$ ( $y$ axis) and $\beta _ { 2 }$ $x$ axis). Each result is averaged over 4 experiments.
+
+downscales the final LN of both the encoder and decoder, which reduces the variance of the encoder and decoder during the forward pass. Another strategy GradInit learns is to downscale the weights of the output projection and the FFN layers, so that the residual branch is relatively down-weighted compared with the skip connection, similar to Admin.
+
+Removing warmup without architectural change. Another widely observed phenomenon is that adaptive methods such as Adam seem to be much better than SGD for training Transformer-based language models [13]. Table 7 shows that, with GradInit, we can find a good initialization for the Post-LN Transformer on IWSLT-14 DE-EN that trains using SGD without learning rate warmup nor gradient clipping, and achieves performance close to Adam trained using the same type of learning rate schedule. By comparison, Admin also makes the Transformer trainable with SGD, but the BLEU score is lower than the one initialized with GradInit. By comparing Figures 9 and $1 0$ in the Appendix, we find GradInit for Adam and SGD adopts different rescaling patterns, with the Adam version depending more on downscaling the residual branches through the FFN and output projection layers than the SGD version, and the SGD version downscaling more in the final FFN block of the decoder. This highlights the importance of considering the optimization algorithm $\mathcal { A }$ in GradInit, and also indicates the presence of different ways to reduce the initial gradient variance.
+
+# 5 Conclusion
+
+In this paper, we propose GradInit, a gradient-based initialization scheme for any architecture. GradInit reinitializes a network by learning a scale factor for each randomly initialized parameter block of a network, so that the training loss evaluated on a different minibatch after one gradient step of a specific stochastic optimizer is minimized. Such a design takes the stochasticity, the learning rate, and the direction of the optimizer into account, allowing us to find better initializations tailored for the optimizer. The initialization learned by GradInit often decreases the gradient variance for most of the parameter blocks. We show that GradInit accelerates the convergence and improves the test performance of a variety of architectures on image classification. It also enables training the Post-LN Transformer without any form of learning rate warmup, even for SGD. GradInit can be a useful tool in the future discovery of better neural architectures that are otherwise discarded due to poor initializations. By analyzing the learned scaling coefficients and their impact on gradient variance, it can also serve a guide to design better initialization schemes for complex architectures to shorten the training schedule and save energy.
+
+# 6 Acknowledgement
+
+This project was supported by the Office of Naval Research, AFOSR MURI program, the DARPA Young Faculty Award, and the National Science Foundation Division of Mathematical Sciences. Additional support was provided by Capital One Bank and JP Morgan Chase.
+
+References   
+[1] Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In AISTATS, 2010.   
+[2] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In CVPR, 2015.   
+[3] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, pages 5998–6008, 2017.   
+[4] Ruibin Xiong, Yunchang Yang, Di He, Kai Zheng, Shuxin Zheng, Chen Xing, Huishuai Zhang, Yanyan Lan, Liwei Wang, and Tieyan Liu. On layer normalization in the transformer architecture. In ICML, 2020.   
+[5] Xiao Shi Huang, Felipe Perez, Jimmy Ba, and Maksims Volkovs. Improving transformer optimization through better initialization. In ICML, 2020.   
+[6] Liyuan Liu, Xiaodong Liu, Jianfeng Gao, Weizhu Chen, and Jiawei Han. Understanding the difficulty of training transformers. EMNLP, 2020.   
+[7] Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019.   
+[8] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. NeurIPS, 2020.   
+[9] Hongyi Zhang, Yann N Dauphin, and Tengyu Ma. Fixup initialization: Residual learning without normalization. In ICLR, 2019.   
+[10] Soham De and Sam Smith. Batch normalization biases residual blocks towards the identity function in deep networks. NeurIPS, 2020.   
+[11] Andrew Brock, Soham De, and Samuel L Smith. Characterizing signal propagation to close the performance gap in unnormalized resnets. ICLR, 2021.   
+[12] Andrew Brock, Soham De, Samuel L. Smith, and Karen Simonyan. High-performance largescale image recognition without normalization. arXiv preprint arXiv:2102.06171, 2021.   
+[13] Jingzhao Zhang, Sai Praneeth Karimireddy, Andreas Veit, Seungyeon Kim, Sashank J Reddi, Sanjiv Kumar, and Suvrit Sra. Why are adaptive methods good for attention models? NeurIPS, 2020.   
+[14] Andrew M Saxe, James L McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. ICLR, 2014.   
+[15] Dmytro Mishkin and Jiri Matas. All you need is a good init. ICLR, 2016.   
+[16] Yann N Dauphin and Samuel Schoenholz. Metainit: Initializing learning by learning to initialize. In NeurIPS, pages 12645–12657, 2019.   
+[17] Mert Gurbuzbalaban and Yuanhan Hu. Fractional moment-preserving initialization schemes for training deep neural networks. In International Conference on Artificial Intelligence and Statistics, pages 2233–2241. PMLR, 2021.   
+[18] Charles H Martin and Michael W Mahoney. Traditional and heavy-tailed self regularization in neural network models. arXiv preprint arXiv:1901.08276, 2019.   
+[19] Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, pages 448–456, 2015.   
+[20] Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.   
+[21] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pages 770–778, 2016.   
+[22] Thomas Bachlechner, Bodhisattwa Prasad Majumder, Huanru Henry Mao, Garrison W Cottrell, and Julian McAuley. Rezero is all you need: Fast convergence at large depth. arXiv preprint arXiv:2003.04887, 2020.   
+[23] Sanjeev Arora, Zhiyuan Li, and Kaifeng Lyu. Theoretical analysis of auto rate-tuning by batch normalization. In International Conference on Learning Representations, 2019.   
+[24] Ruosi Wan, Zhanxing Zhu, Xiangyu Zhang, and Jian Sun. Spherical motion dynamics of deep neural networks with batch normalization and weight decay. arXiv preprint arXiv:2006.08419, 2020.   
+[25] Lukas Balles and Philipp Hennig. Dissecting adam: The sign, magnitude and variance of stochastic gradients. In ICML, pages 404–413, 2018.   
+[26] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.   
+[27] J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR, 2009.   
+[28] Mauro Cettolo, Jan Niehues, Sebastian Stüker, Luisa Bentivogli, and Marcello Federico. Report on the 11th iwslt evaluation campaign, iwslt 2014. In IWSLT, volume 57, 2014.   
+[29] Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, and Michael Auli. fairseq: A fast, extensible toolkit for sequence modeling. In NAACL-HLT (Demonstrations), 2019.   
+[30] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2015.   
+[31] Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint arXiv:1608.03983, 2016.   
+[32] Priya Goyal, Piotr Dollár, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.   
+[33] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations, 2018.   
+[34] Chen Zhu, Yu Cheng, Zhe Gan, Furong Huang, Jingjing Liu, and Tom Goldstein. Maxva: Fast adaptation of step sizes by maximizing observed variance of gradients. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pages 628–643. Springer, 2021.   
+[35] Liyuan Liu, Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Jiawei Han. On the variance of the adaptive learning rate and beyond. ICLR, 2020.   
+[36] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.   
+[37] Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.   
+[38] Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In CVPR, 2017.   
+[39] Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017.   
+[40] Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. ICLR, 2018.   
+[41] Jeremy Bernstein, Yu-Xiang Wang, Kamyar Azizzadenesheli, and Animashree Anandkumar. signsgd: Compressed optimisation for non-convex problems. In ICML, 2018.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] One limitation of our current work is we have not checked whether GradInit can improve the training of models from other domains such as speech.   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes]   
+(b) Did you mention the license of the assets? [Yes]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/eXlxB3aLOe/eXlxB3aLOe_content_list.json

@@ -0,0 +1,1208 @@
+[
+    {
+        "type": "text",
+        "text": "GradInit: Learning to Initialize Neural Networks for Stable and Efficient Training ",
+        "text_level": 1,
+        "bbox": [
+            181,
+            122,
+            818,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chen Zhu University of Maryland chenzhu@cs.umd.edu ",
+        "bbox": [
+            217,
+            226,
+            372,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Renkun Ni University of Maryland rn9zm@cs.umd.edu ",
+        "bbox": [
+            419,
+            226,
+            576,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zheng Xu Google Research xuzheng@google.com ",
+        "bbox": [
+            624,
+            226,
+            782,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Kezhi Kong University of Maryland kong@cs.umd.edu ",
+        "bbox": [
+            223,
+            289,
+            380,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "W. Ronny Huang Google Research wrh@google.com ",
+        "bbox": [
+            437,
+            289,
+            562,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tom Goldstein University of Maryland tomg@cs.umd.edu ",
+        "bbox": [
+            617,
+            289,
+            774,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            367,
+            535,
+            382
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Innovations in neural architectures have fostered significant breakthroughs in language modeling and computer vision. Unfortunately, novel architectures often result in challenging hyper-parameter choices and training instability if the network parameters are not properly initialized. A number of architecture-specific initialization schemes have been proposed, but these schemes are not always portable to new architectures. This paper presents GradInit, an automated and architecture agnostic method for initializing neural networks. GradInit is based on a simple heuristic; the norm of each network layer is adjusted so that a single step of SGD or Adam with prescribed hyperparameters results in the smallest possible loss value. This adjustment is done by introducing a scalar multiplier variable in front of each parameter block, and then optimizing these variables using a simple numerical scheme. GradInit accelerates the convergence and test performance of many convolutional architectures, both with or without skip connections, and even without normalization layers. It also improves the stability of the original Transformer architecture for machine translation, enabling training it without learning rate warmup using either Adam or SGD under a wide range of learning rates and momentum coefficients. Code is available at https://github.com/zhuchen03/gradinit. ",
+        "bbox": [
+            232,
+            397,
+            766,
+            632
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            656,
+            310,
+            674
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The initialization of network parameters has a strong impact on the training stability and performance of deep neural networks. Initializations that prevent gradient explosion/vanishing in back propagation played a key role in early successes with feed-forward networks [1, 2]. Even with cleverly designed initialization rules, complex models with many layers or multiple branches can still suffer from instability. For example, the original Transformer model [3] does not converge without learning rate warmup using the default initialization [4–6]; RoBERTa [7] and GPT-3 $\\pmb { \\| \\widetilde { \\ 8 } \\| }$ have to tune the $\\beta _ { 2 }$ parameter of Adam for stability when the batch size is large. Recent innovations have shown that architecture-specific initializations, which are carefully derived to maintain stability, can promote convergence without needing normalization layers [5, 9–12]. Unfortunately, the reliance on analytically derived initializations makes it difficult to realize the benefits of these methods when performing architecture search, training networks with branched or heterogeneous components, or proposing altogether new architectures. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            853
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose a simple method for learning the initialization of a network with any architecture. Typically, initialization schemes draw parameters independently from a zero-mean distribution, with the variance of each distribution set to pre-determined values depending on the dimensions of the layers [1, 2]. Rather than deriving a closed-form expression for the these distribution parameters, our method re-scales each random weight tensor (e.g. convolution kernels) directly by a learned scalar coefficient. This small set of coefficients is optimized to make the first step of a stochastic optimizer (e.g. SGD or Adam) as effective as possible at minimizing the training loss, while preventing the initial gradient norm from exploding. In addition, this process is designed to take into account the direction, step size, and stochasticity of the optimizer. Finally, after the variance has been learned for each parameter tensor, the random network parameters are re-scaled and optimization proceeds as normal. We empirically find that our methods can make the initialization fall into a smooth loss region, reduce the inter-sample gradient variance, and accelerates training. ",
+        "bbox": [
+            176,
+            859,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            215
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our proposed method, GradInit, is architecture agnostic, and works with both Adam and SGD optimizers. In the vision domain, we show it accelerates the convergence and test performance of a variety of deep architectures, from the vanilla feed-forward VGG net to ResNet, with or without Batch Normalization. It is efficient and scalable, finding good initializations using less than $1 \\%$ of the total training time in our experiments, and it improves the initialization of ResNet-50 on ImageNet to obtain better final test accuracy. In the language domain, GradInit enables training the original Transformer model $\\mathbb { \\left[ 3 \\right] }$ using either Adam or SGD without learning rate warmup for machine translation, which is commonly acknowledged to be difficult [4, 13]. As an extreme example of the capabilities of GradInit, we use it to initialize and train a 1202-layer ResNet that achieves significantly higher test accuracy than ResNet-110, which other initialization methods have failed to achieve. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, by visualizing the initial norms and gradient variances of the weights before and after GradInit is applied, we show that GradInit is a useful tool for identifying potential causes for instability at initialization, such as those imposed by normalization layers, and we summarize interesting scale patterns learned by GradInit that can be helpful for designing better initialization rules. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            422
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            443,
+            321,
+            460
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Controlling the norms of network parameters at initialization has proven to be an effective approach for speeding up and stabilizing training. Glorot and Bengio $\\mathbb { M }$ studied how the variance of features evolves with depth in feed-forward linear neural networks by assuming both activations and weight tensors are independent and identical random variables. They developed a technique in which the variance of each filter scales with its fan-in (the number of input neurons). This style of analysis was later generalized to the case of ReLU networks $\\pmb { \\mathbb { Z } } ] \\mathbf { l }$ . These two analyses are most effective for feed-forward networks without skip connections or normalization layers. Based on the orthogonal initialization scheme $\\pmb { \\mathbb { I } }$ , Mishkin and Matas $\\mathbb { \\left. \\boldsymbol { \\cdot } \\boldsymbol { \\cdot } \\right. }$ proposed an iterative procedure to rescale the orthogonally initialized weights of each layer in feedforward networks so that the activations of that layer have unit variance. However, this method fails to prevent the blowup of activations with depth for ResNets [16]. Recently, Gurbuzbalaban and Hu $\\mathbb { \\ m }$ proposed initialization schemes such that the network can provably preserve any given moment of order $s \\in ( 0 , 2 ]$ for the output of each layer. The motivation is that the stochastic gradient updates can result in heavy-tailedness in the distribution of the network weights with a potentially infinite variance, but finite $s$ -order moment $\\mathbb { \\lVert 1 8 \\rVert }$ . Again, these initialization schemes can only be applied for feed-forward neural networks. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            684
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For more complex architectures, normalization layers $\\mathbb { I m } \\mathbb { Q } \\mathbb { L O } \\mathbb { I }$ and skip connections $\\pmb { \\mathbb { Z } } 1 \\Vert$ stabilized training dynamics and improved the state-of-the-art. Similarly, learning rate warmup is a common trick for training large Transformers $\\mathbb { \\left[ 3 \\right] }$ . These methods make training tractable for some models, but do not eliminate the high initial gradient variance that destabilizes training when the network is deep [9–11] or when the normalization layers are not carefully positioned [4]. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            760
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Several authors have proposed better initializations for networks with skip connections. This is often achieved by replacing the normalization layers with simpler scaling or bias operations, and scaling the weight matrices in each layer so that the variance of activations does not increase with depth [9– 12]. Similar analysis has been applied to self attention in Transformers [5]. Without removing the normalization layers, it is possbile to stabilize the initial parameter updates by introducing carefully initialized learnable scale factors to the skip connections $\\pmb { \\Vert 6 \\Vert }$ or the residual branches $[ [ 2 2 ] ]$ . However, such techniques are often restricted to one specific architecture such as ResNets. ",
+        "bbox": [
+            173,
+            766,
+            825,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, Dauphin and Schoenholz $\\boxed { \\boxed { 1 6 } }$ proposed a task-agnostic and automatic initialization method, MetaInit, for any neural network achitecture. MetaInit optimized the norms of weight tensors to minimize the “gradient quotient”, which measures the effect of curvature near the initial parameters, on minibatches of random Gaussian samples. However, as training data is usually accessible for most tasks of interest, it is simpler and potentially more efficient to use the training data for initialization. MetaInit also involves the gradient of a Hessian-vector product that requires computing a “gradient of the gradient” multiple times in tandem, which is very computationally intensive. Our proposed method distinguishes itself from MetaInit in the following ways: (i) Our method is more computationally efficient. MetaInit involves computing third-order derivatives, results in long computing times and high memory usage. The memory overhead of MetaInit is more of an issue for networks with normalization layers. For the relatively small-scale CIFAR-10 problem with batch size 64, MetaInit requires three GPUs (RTX 2080Ti), while the proposed GradInit needs just one. (ii) Our method takes the stochasticity of minibatches into consideration. MetaInit uses the local curvature evaluated on a single minibatch, which fails to capture the variance of the loss/gradient between two different stochastic minibatches. (iii) Our method considers the training dynamics of different optimization algorithms including the learning rate and the direction of the gradient step, and effectively handles different optimizers including SGD and Adam. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            285
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            304,
+            271,
+            320
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We aim to develop an initialization scheme applicable to arbitrary network architectures. Since previous works [1, 2, 9, 16, 10, 12] have shown that the initial weight norms effectively control the initial gradient norm on average, our method rescales the randomly initialized weight matrices using learnable scale factors.1 ",
+        "bbox": [
+            174,
+            335,
+            825,
+            391
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Using a small number of gradient descent steps on these scale factors, the proposed GradInit method chooses the initialization scalars so that the loss after the first gradient step taken by a stochastic optimizer (SGD or Adam) is as low as possible. The process of learning initialization coefficients accounts for the chosen learning rate, optimizer, and other parameters. To prevent gradient explosion, our method enforces a constraint that the gradient norm is no larger than a constant $\\gamma$ . ",
+        "bbox": [
+            174,
+            397,
+            825,
+            467
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that for scale-invariant weights, e.g., convolution kernels before BN layers, rescaling still changes their learning dynamics by changing their effective learning rate $\\pm \\overbrace { 1 2 3 } , \\textcircled { 2 4 } ]$ . Empirically, GradInit goes beyond simply preventing exploding or vanishing gradients; it also reduces the gradient variance, making the initialization fall into a smooth loss region with small gradient variance so that training is fast, see discussion about Figure $\\bigstar$ and comparisons in Figure $\\bigtriangledown$ ",
+        "bbox": [
+            174,
+            473,
+            825,
+            544
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Efficient Learning-based Initialization via Constrained Optimization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            558,
+            691,
+            574
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We begin by filling all the weight matrices $\\{ W _ { 1 } , \\hdots , W _ { M } \\}$ of the network with values drawn from independent zero-mean Gaussian distributions, except for the scales and biases of the normalization layers (if any), which are initialized to 1 and 0 respectively. During the initialization process, we keep $\\{ W _ { 1 } , \\hdots , W _ { M } \\}$ constant, but we multiply each $W _ { i }$ with a learnable non-negative scale factor $\\alpha _ { i }$ (initialized to 1). After initialization, we rescale the weights by the learned scale factors, and start training without the learnable scale factors just as normal. We use $\\pmb { m } = \\{ \\alpha _ { 1 } , . . . , \\alpha _ { M } \\}$ to denote the set of scale factors, and $\\pmb { \\theta } _ { m } = \\{ \\alpha _ { 1 } \\pmb { W } _ { 1 } , \\ldots , \\alpha _ { M } \\pmb { W } _ { M } \\}$ is the set of rescaled weight matrices. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            683
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $\\begin{array} { r } { L ( S ; \\pmb { \\theta } ) = \\frac { 1 } { | S | } \\sum _ { x \\in S } \\ell ( x ; \\pmb { \\theta } ) } \\end{array}$ be the average loss of the model parameterized by $\\pmb \\theta$ on a minibatch of samples $S$ , where $| S |$ is the number of samples in the minibatch. We use $\\pmb { g } _ { S , \\pmb { \\theta } } = \\nabla _ { \\pmb { \\theta } } L ( S ; \\pmb { \\theta } )$ as a shorthand for the gradient of $\\pmb { \\theta }$ . During standard training, this gradient is preprocessed/preconditioned by the optimization algorithm $\\mathcal { A }$ , and then used to update the network parameters. GradInit solves the following constrained optimization problem: ",
+        "bbox": [
+            174,
+            685,
+            825,
+            761
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2487a7d56698ad132194476b7617b22526001fe6abbdc781d205ff09630abc2f.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\underset { m } { \\mathrm { m i n i m i z e } } } & { L ( \\tilde { S } ; \\pmb { \\theta } _ { m } - \\eta \\mathcal { A } [ \\pmb { g } _ { S , \\pmb { \\theta } _ { m } } ] ) , } \\\\ { \\mathrm { s u b j e c t ~ t o ~ } } & { \\| \\pmb { g } _ { S , \\pmb { \\theta } _ { m } } \\| _ { p , s } \\le \\gamma , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            766,
+            622,
+            813
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $S$ and $\\tilde { S }$ are two different minibatches, $\\eta$ is a prescribed learning rate for the optimization algorithm $\\mathcal { A }$ , $p _ { \\mathcal { A } }$ is the $\\ell _ { p }$ -norm associated with $\\mathcal { A }$ , and $\\gamma$ is the upper bound for the norm. For the first gradient step, Adam uses $\\mathcal { A } [ g _ { S , \\theta _ { m } } ] = \\mathrm { s i g n } ( g _ { S , \\theta _ { m } } ) \\left[ \\left[ 2 5 \\right] \\right]$ , while SGD uses $\\mathcal { A } [ g ( S ; \\theta _ { m } ) ] =$ ",
+        "bbox": [
+            174,
+            819,
+            825,
+            863
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$\\gamma \\pmb { g } ( S ; \\pmb { \\theta } _ { m } ) / \\| \\pmb { g } ( S ; \\pmb { \\theta } _ { m } ) \\| _ { 2 }$ . We show how to choose $\\gamma$ and $p _ { \\cal A }$ without tuning in Section 3.3. We discuss the formulation of this problem and how to solve it below. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Solving the Constrained Problem ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            140,
+            442,
+            155
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The problem $( 1 )$ is solved using a stochastic gradient descent method in which we sample new mini-batches on each iteration. Since the proposed method uses gradient updates to compute the initialization, we dub it GradInit. We propose a simple solver to optimize objective $( 1 )$ in Algorithm 1 A key feature of our method is that is makes a simple approximation: after $g _ { S , \\theta _ { m } }$ is computed on the forward pass of an iteration, we treat $\\mathcal { A } [ \\pmb { g } _ { S } , \\pmb { \\theta } _ { m } ]$ as a constant and do not back-propagate through $\\mathcal { A } [ \\pmb { g } _ { S } , \\pmb { \\theta } _ { m } ]$ on the backward pass. We make this choice to keep computing costs low, and because it is not possible to back-propagate through the non-differentiable sign function for Adam. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            265
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/37d2f1f6ff2fc475153ce55d1616a350bf22027fc6624ecec645f1eeab46d211.jpg",
+        "table_caption": [
+            "Algorithm 1 GradInit for learning the initialization of neural networks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>1: Input: Target optimization algorithm Aand learning raten for model training, initial model parameters 0o, learningrateTof the GradInit scales m,total iterations T,upper boundof the gradienty,lower bound for</td><td></td></tr><tr><td>2:mi←1</td><td>the initialization scalars α= O.01.</td><td></td></tr><tr><td></td><td>3: for t = 1 to T do</td><td></td></tr><tr><td>4:</td><td>Sample St from training set.</td><td></td></tr><tr><td>5:</td><td>Lt←S l(xk;0mt)，gt←VθLt</td><td></td></tr><tr><td>6:</td><td>if |lgtllpA &gt;γ then</td><td></td></tr><tr><td>7:</td><td>mt+1 ← mt -TVmtllgtllpA</td><td></td></tr><tr><td>8:</td><td>else</td><td></td></tr><tr><td>9:</td><td>Sample St from training set.</td><td></td></tr><tr><td>10:</td><td>Lt+1←s∑x∈ste(xk;Omt-nAlgt]）</td><td></td></tr><tr><td>11: 12:</td><td>mt+1←mt-TVmtLt+1</td><td></td></tr></table>",
+        "bbox": [
+            176,
+            301,
+            826,
+            497
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To enforce the constraint in $( 1 )$ , we test whether the constraint is satisfied after computing $\\pmb { g } ( S ; \\pmb { \\theta } _ { m } )$ . If not, we take a gradient descent step to minimize $\\| \\pmb { g } ( S ; \\pmb { \\theta } _ { m } ) \\| _ { p _ { A } }$ , which involves computing second A order derivatives. If the constraint is satisfied, then we instead compute a gradient descent step for the loss. In addition, we set a lower bound $\\underline { { \\alpha } } = 0 . 0 1$ for all $\\alpha _ { i }$ . We find that this prevents scalars from landing on small values during minimization and keeps the GradInit optimizer stable. In our experiments, we find the only layer that ever hit this lower bound is the final FC layer on some networks (see the figures in Section $4 . 1 )$ . We find this procedure converges reliably within 2000 iterations for ImageNet, and fewer than 400 iterations for CIFAR-10, taking less than $1 \\%$ of the total training time on both problems. We also find it works well to set the step size $\\tau$ to values within the range between $1 0 ^ { - 3 }$ and $1 0 ^ { - 1 }$ . During initialization, the gradient norm constraint is satisfied for the majority of iterations. The choice of $\\gamma , p _ { \\mathcal { A } }$ will be discussed in Section $\\underline { { \\boldsymbol { \\left. 3 . 3 \\right. } } }$ ",
+        "bbox": [
+            173,
+            511,
+            826,
+            665
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Stochasticity of mini-batching. The objective in $( 1 )$ uses two different mini-batches; $S$ is used to compute the gradient, and $\\tilde { S }$ is used to compute the loss. Ideally, $S$ and $\\tilde { S }$ should be independently sampled from the training set to capture the randomness of the stochastic optimizer. However, when the network has large initial gradient variance, the gradients on $S$ and $\\tilde { S }$ usually differ a lot, and for $\\tilde { S }$ , the gradient update step $\\theta _ { m } - \\eta \\mathcal { A } \\left[ g _ { S , \\theta _ { m } } \\right]$ becomes more similar to adding random perturbations to the parameters. We find our objective less effective at accelerating convergence in this case, as shown by the first-epoch accuracy $( A c c _ { 1 } )$ in Table $^ { 1 . }$ On the other hand, the randomness is not captured if $S = \\tilde { S }$ , and we find empirically that $\\theta _ { m }$ can exploit the loss by increasing the gradient norm and destabilize training in this case (see Table $\\textcircled{8}$ . Without excessive tuning, we find that we get more reliable behavior for different architectures when $\\tilde { S }$ is a mixture of $50 \\%$ samples from $S$ and $50 \\%$ re-sampled training data, and use this setting by default unless otherwise stated. ",
+        "bbox": [
+            174,
+            683,
+            553,
+            824
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/99c5b717a3e991056b4ebb5839d9fc6f39eea1063d0888677697a47d53e9ba89.jpg",
+        "table_caption": [
+            "Table 1: Accuracies on CIFAR-10 using different overlapping ratios of $\\tilde { S }$ and $S$ for GradInit. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Sns |S]</td><td>Acc1</td><td>AcCbest</td></tr><tr><td>VGG-19</td><td>0</td><td>21.9 ± 4.4</td><td>94.5 ± 0.1</td></tr><tr><td>w/o BN</td><td>0.5</td><td>29.3 ± 0.6</td><td>94.7± 0.02</td></tr><tr><td>(20.03 M)</td><td>1</td><td>28.7 ± 1.0</td><td>94.5 ± 0.1</td></tr></table>",
+        "bbox": [
+            566,
+            746,
+            821,
+            806
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            825,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 Setting and Enforcing the Constraint ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            90,
+            470,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The constraint in $\\mathbb { \\underline { { ( 1 ) } } }$ is included to prevent the network from minimizing the loss in a trivial way by blowing up the initial gradient. In other words, we want the optimizer to achieve small loss by choosing an effective search direction rather than by taking an extremely large step in a sub-optimal direction. ",
+        "bbox": [
+            174,
+            116,
+            825,
+            172
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Setting $p _ { \\cal A }$ and $\\gamma$ through first-order approximation. We show that $p _ { \\mathcal { A } }$ and $\\gamma$ can be set easily with a rule of thumb and without a parameter search. From the first-order approximation, we expect the first gradient step to result in a change in the loss on $S$ as following: ",
+        "bbox": [
+            174,
+            188,
+            823,
+            231
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0feceaf154e60bd08891f0234c7af53f813f0c6c744fe1227cca2cc2fb3b60c8.jpg",
+        "text": "$$\nL ( S ; \\theta _ { m } - \\eta \\mathcal { A } [ g _ { S , \\theta _ { m } } ] ) - L ( S ; \\theta _ { m } ) \\approx - \\eta \\mathcal { A } [ g _ { S , \\theta _ { m } } ] ^ { T } g _ { S , \\theta _ { m } } = \\left\\{ \\begin{array} { l l } { - \\eta \\| g _ { S , \\theta _ { m } } \\| _ { 2 } ^ { 2 } , } & { \\mathrm { i f ~ } \\mathcal { A } \\mathrm { ~ i s ~ S G D } , } \\\\ { - \\eta \\| g _ { S , \\theta _ { m } } \\| _ { 1 } , } & { \\mathrm { i f ~ } \\mathcal { A } \\mathrm { ~ i s ~ A d a m } . } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            238,
+            795,
+            273
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To effectively bound the approximated change in Eq. $^ { 2 , }$ we choose $\\ell _ { p _ { A } }$ to be the $\\ell _ { 2 }$ and $\\ell _ { 1 }$ norm for ASGD and Adam respectively, so when the constraint is satisifed, the maximum change in the loss, according to our local approximation, is $\\eta \\gamma ^ { 2 }$ for SGD and $\\eta \\gamma$ for Adam. We recommend setting $\\gamma$ such that $\\eta \\gamma ^ { 2 } = 0 . 1$ for SGD and $\\eta \\gamma = 0 . 1$ for Adam. According to the linear approximations, this limits the gradient magnitude so that the first step of SGD can decrease the loss by at most 0.1. This simple rule was used across all vision and language experiments. ",
+        "bbox": [
+            173,
+            280,
+            826,
+            366
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Why a constraint and not a penalty? Instead of formulating GradInit as a constrained optimization, one can alternatively formulate it as minimizing the objective with a gradient penalty: minimize $L ( \\tilde { S } ; \\theta _ { m } - \\eta A \\left[ \\pmb { g } _ { S , \\theta _ { m } } \\right] ) + \\lambda \\Vert \\pmb { g } _ { S ; \\theta _ { m } } \\Vert _ { p _ { A } }$ , where $\\lambda > 0$ is the penalty strength. ",
+        "bbox": [
+            173,
+            381,
+            826,
+            428
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The penalized objective has two drawbacks compared to the constrained one in Eq. $^ { 1 . }$ First, every gradient descent step on the penalized objective involves second-order gradients due to the gradient regularization, while the constrained form does not need second-order gradients when the constraint is satisfied. Second, it is difficult to choose a good $\\lambda$ that works well for all architectures. By contrast, we set $\\gamma$ by analyzing the first-order approximation mentioned above, and find the same $\\gamma$ works well for different architectures. The results supporting these two points are given in Table 2. ",
+        "bbox": [
+            174,
+            429,
+            485,
+            609
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/b457567bd8d4c3aa8a065e849d6c7fd5ebacb1b9c41b7229d211fcc45292250b.jpg",
+        "table_caption": [
+            "Table 2: Time cost and accuracy (average of 4 runs) for running one epoch of regularization/constrained form of GradInit. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>VGG-19 w/o BN</td><td>VGG-19 W/BN</td><td>ResNet-110 ResNet-110 w/o BN w/BN</td></tr><tr><td>Time (s)</td><td>82 vs.56</td><td>100 vs. 62</td><td>169 vs.103 269vs.195</td></tr><tr><td>入=10-4</td><td>32.3,94.6</td><td>10.6,93.1</td><td>33.7,93.9 32.4,95.2</td></tr><tr><td>入=10-2</td><td>30.4,94.5</td><td>10.4,93.0</td><td>36.7,94.1 32.6,95.3</td></tr><tr><td>入=1</td><td>18.2, 74.7</td><td>38.5,95.1</td><td>30.7,94.2 36.5,95.3</td></tr><tr><td>γ=1</td><td>29.3,94.7</td><td>47.8, 95.1</td><td>36.2,94.6 38.2, 95.4</td></tr></table>",
+        "bbox": [
+            500,
+            478,
+            821,
+            577
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            628,
+            312,
+            646
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We evaluate GradInit on benchmark datasets for image classification and machine translation tasks. For image classification, five different architectures are evaluated for CIFAR10 [26], and ResNet-50 is evaluated for ImageNet [27]. For machine translation, we use GradInit to find good initializations for a Post-LN Transformer without any change to its original architecture on IWSLT-14 De-En [28]. We observe that the method can remove the necessity of any form of learning rate warmup for both Adam and SGD. ",
+        "bbox": [
+            173,
+            660,
+            826,
+            743
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We conduct our experiments in PyTorch. We use the fairseq library for machine translation $\\left[ \\left[ 2 9 \\right] \\right]$ . All the experiments on CIFAR-10 and IWSLT-14 DE-EN can run with one single NVIDIA RTX 2080 Ti GPU with 11GB of RAM. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            791
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "GradInit first initializes the weights using Kaiming initialization [2] for all the Conv and FC layers for image classification. For machine translation, we use the default Xavier initialization [1]. We optimize the scale factors $\\left\\{ \\alpha _ { i } \\right\\}$ with Adam $\\pmb { \\mathbb { B } } 0 \\|$ using the default momentum parameters. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Image Datasets with Various Architectures ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            857,
+            511,
+            872
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The introduction of Batch Normalization (BN) $\\mathbb { \\lVert 1 9 \\rVert }$ and skip connections makes it relatively easy to train common CNNs for image classification to achieve high accuracy. Despite this, we show that ",
+        "bbox": [
+            176,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "when the network is very deep, the network is unstable even when both BN and skip connections are used, and GradInit can significantly improve the stability. The results on CIFAR-10 are given in Table 3 and results on ImageNet are given in Table 6. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            135
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 Settings ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            148,
+            281,
+            164
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Architectures. On CIFAR-10, we focus on the feedforward VGG net and the prevalent and powerful ResNet, with and without BN layers. For networks without BN, we use learnable biases in all layers. For ResNet, we additionally evaluate a deep 1202-layer version. We give results for other architectures (Wide ResNet, DenseNet) in Appendix E due to space limits. We compare with four different methods/settings: 1) Kaiming Initialization [2]; 2) First train the network for one epoch with a constant learning rate equal to the starting learning rate, labelled as $^ { 6 } { + } 1$ epoch (Const. LR)\" in Table 3; 3) First train the network for one epoch with a linear warmup learning rate, labbeled as $^ { 6 6 } { + 1 }$ epoch (Warmup)\" in Table 3; 4) MetaInit [16]. ",
+        "bbox": [
+            173,
+            174,
+            825,
+            286
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On ImageNet, we use the ResNet-50 model $\\mathbb { \\left| \\mathbb { Z } \\right\\| }$ . We compare with Kaiming Initialization, FixUp initialization $[ [ 9 $ and MetaInit. For the ResNet-50 without BN, we follow the architecture of FixUp for fair comparisons, but we still use the original Kaiming initialization as the starting point of GradInit. ",
+        "bbox": [
+            176,
+            290,
+            823,
+            333
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameters. We set $\\mathcal { A }$ to SGD and $\\eta = 0 . 1$ (the same as the base learning rate) for GradInit in all image classification experiments. On CIFAR-10, we train networks with a batch size of 128. We find MetaInit often takes 2 to 3 times as much memory as GradInit. We run GradInit or MetaInit for one epoch on the data, which takes less than $1 \\%$ of the total training time. For GradInit, according to our analysis in Section $^ { 3 . 3 , }$ we fix the gradient norm constraint $\\gamma = 1$ in all these experiments. Therefore, as in MetaInit, the only hyperparameter that needs to be tuned is the learning rate $\\tau$ of the scale factors. We do a grid search on $\\tau$ in the range $[ 1 0 ^ { - 3 } , 1 0 ^ { - 1 } ]$ , and report the results with the best average final test accuracy on 4 runs. After GradInit initialization, we use a learning rate of 0.1 and the cosine annealing learning rate schedule without restart $\\textcircled { \\scriptsize { 1 3 1 } }$ to train the model for 200 epochs, where the learning rate decays after each iteration and decays to 0 in the last iteration. Due to their high initial gradient variance (see Figure $^ { 6 ) }$ , we have applied gradient clipping (maximum norm is 1) to all non-BN networks so that they converge without GradInit under the same schedule. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            505
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On ImageNet, we train the ResNet-50 model for 90 epochs with a total batch size of 256 on 4 GPUs. Due to the difference in the library for training and the number of GPUs used, which affects the BN statistics, our baseline top-1 accuracy of ResNet-50 (w/ BN) on ImageNet is $0 . 7 9 \\%$ lower than $\\pmb { \\mathbb { B 2 } }$ . We use SGD with a starting learning rate of 0.1 and decay the learning rate by 10 after the $3 0 \\mathrm { t h }$ and 60th epoch. We provide additional details in Appendix A. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            582
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.2 Results and Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            597,
+            369,
+            612
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/50a4c47abcd983072ed8704ae0cbb47dca42929bbd5db005f7bb97b8fc00e0b0.jpg",
+        "table_caption": [
+            "Table 3: First epoch $( A c c _ { 1 } )$ and best test accuracy over all epochs $( A c c _ { b e s t } )$ for models on CIFAR-10. We report the mean and standard error of the test accuracies in 4 experiments with different random seeds. Best results in each group are in bold. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Model (#Params)</td><td>VGG-19 w/o BN (20.03M)</td><td>VGG-19 w/BN (20.04M)</td><td>ResNet-110 w/o BN (1.72M)</td><td>ResNet-110 w/BN (1.73M)</td><td>ResNet-1202 w/BN (19.42M)</td></tr><tr><td rowspan=\"2\">Kaiming</td><td>AcC1</td><td>29.1 ± 1.5</td><td>12.6 ± 0.6</td><td>16.1 ± 2.1</td><td>23.2 ± 0.9</td><td>12.9 ± 2.8</td></tr><tr><td>AcCbest</td><td>94.5 ± 0.1</td><td>94.4 ± 0.1</td><td>94.2 ± 0.1</td><td>95.0± 0.2</td><td>94.4 ± 0.6</td></tr><tr><td rowspan=\"2\">+1 epoch (Const. LR)</td><td>Acc1</td><td>37.2 ± 1.1</td><td>19.6 ± 4.0</td><td>21.0 ± 3.8</td><td>32.5 ±3.8</td><td>12.6 ± 2.8</td></tr><tr><td>Accbest</td><td>94.4± 0.1</td><td>94.5 ± 0.1</td><td>93.9 ± 0.4</td><td>94.7 ± 0.3</td><td>94.0 ± 0.4</td></tr><tr><td rowspan=\"2\">+1 epoch (Warmup)</td><td>Acc1</td><td>37.4 ±1.2</td><td>53.5 ± 2.9</td><td>19.8 ± 0.5</td><td>48.7 ± 1.1</td><td>28.1 ± 1.3</td></tr><tr><td>AcCbest</td><td>94.4 ± 0.1</td><td>94.7 ± 0.1</td><td>94.1 ± 0.1</td><td>95.1 ± 0.1</td><td>95.4± 0.2</td></tr><tr><td rowspan=\"2\">MetaInit</td><td>AcC1</td><td>30.5± 0.9</td><td>35.1 ± 0.6</td><td>14.6 ± 2.2</td><td>29.0 ± 1.5</td><td>11.7 ± 1.6</td></tr><tr><td>AcCbest</td><td>94.6 ± 0.1</td><td>94.6 ± 0.1</td><td>94.2 ± 0.1</td><td>94.8 ± 0.1</td><td>95.0 ± 0.5</td></tr><tr><td rowspan=\"2\">GradInit</td><td>AcC1</td><td>29.3±0.6</td><td>47.8 ± 1.8</td><td>36.2 ±0.8</td><td>38.2 ± 0.9</td><td>29.0 ± 1.1</td></tr><tr><td>Accbest</td><td>94.7 ± 0.1</td><td>95.1 ± 0.1</td><td>94.6 ± 0.1</td><td>95.4± 0.1</td><td>96.2 ± 0.1</td></tr></table>",
+        "bbox": [
+            236,
+            676,
+            756,
+            853
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "GradInit further stabilizes feedforward nets with BN. BN does stabilize VGG-19 and allows training without gradient clipping, but with an average first-epoch test accuracy of only 12.57 and an average final test accuracy lower than the version without BN (see Table $3 )$ , it does not seem to eliminate the instability of Kaiming initialization. As shown in Figure $\\bigtriangledown ,$ its initial gradient variance is still relatively high compared with GradInit. BN could magnify the gradient variance when the variance of its input features (in the forward pass) is smaller than 1 (see Appendix $\\boxed { \\mathbf { C } }$ . GradInit reduces the gradient variance by 4 orders of magnitude compared to Kaiming initialization , resulting in significantly higher test accuracy after the first epoch $( 4 7 . 7 9 \\%$ vs. $1 2 . 5 7 \\%$ ), which also has an impact on the final test accuracy $( 9 5 . 1 3 \\%$ vs. $9 4 . 4 1 \\%$ ). The reduction in gradient variance is achieved mainly by scaling down the weights of the final FC layer and the last 2 BN layers, so that the variance of the activations is reduced in the forward pass. This learned behavior is consistent with the strategy of FixUp, where the final FC layer is initialized to 0. Another source of gradient variance reduction is achieved by increasing the weight norms of the remaining Conv and BN layers, so that the variance of the inputs to the BN layers is increased and the gradient magnifying effect of BN is alleviated in the backward pass. This reduced the ratio $\\sigma ( \\pmb { g } _ { 1 } ) / \\bar { \\sigma } ( \\pmb { g } _ { 1 6 } )$ from 204.9 to 164.8 for the Conv layers in Figure 4. By contrast, FixUp only reduces the weight norms, which may not always be the best solution for networks with normalization layers. ",
+        "bbox": [
+            174,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/b1c7d4d91bac8e66a991e0f50cbde8c33271da8b1f33abfd97bece26ad451b27.jpg",
+        "image_caption": [
+            "Figure 1: Top row: results of ResNet-110 on CIFAR-10. Bottom row: results of ResNet-50 on ImageNet. Left two columns: compare the relative cross-batch gradient variance on the training set for the BN and Conv/FC layers before and after GradInit. Right two columns: weight norms before and after GradInit. Ratio between points in the same layer reflects the scale factor. Note each of the residual blocks has 2 and 3 Conv and BN layers for the ResNet-110 and ResNet-50, respectively. The initial relative gradient variance are reduced for all layers except the final linear layer in both settings. The strategies are similar on two different datasets. Within each residual block, the last BN layer has the smallest scaling factors, and the scales of all Conv layers are surprisingly increased. Best viewed in color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            825,
+            289
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/68982e2c5ddf39fc5a9aa28acb3eeeb208468a65c714c3beb3e000e0d69d317f.jpg",
+        "image_caption": [
+            "Figure 2: Comparing the convergence of Kaiming Initialization and GradInit on CIFAR-10, for models trained with SGD (left three) and Adam (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            395,
+            825,
+            497
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            537,
+            825,
+            732
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Deep residual networks still need better initializations. We also gain significant improvements from GradInit for ResNet-110 and ResNet-1202. In ResNets, the skip connections cause the variance of activations to accumulate as the ResNet goes deeper, even for the version with BN $\\mathbb { m }$ . This issue is more significant when the ResNet scales to 1202 layers, from which we can see that with Kaiming initialization, the first-epoch accuracy of ResNet-1202 is quite low, and the final test accuracy is even worse than the shallower ResNet-110, matching the observations of He et al. $\\pmb { \\mathbb { D } } \\mathbf { 1 } \\mathbf { h }$ . Warmup is even more effective than MetaInit at accelerating the convergence and improving the final test accuracy of ResNet-1202, but GradInit still outperforms its final test accuracy by $0 . 8 \\%$ , and the resulting ResNet-1202 finally achieved higher accuracy than ResNet-110. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            863
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The learned layer-wise rescaling patterns of GradInit are even more interesting for ResNets with BN. For ResNets with BN, recall that we have two Conv layers and two BN layers in each residual block. As shown in Figure 1, GradInit learns to increase the weight norms of all the linear layers except for the final FC layer, instead of decreasing as for the case without BN (see Figure $6 )$ . A more unique pattern is the collaborative behavior of the BN weights, where the second BN in each residual block is usually scaled down while the first BN is always scaled up. In deeper layers, the joint effect of these two BN weights is to downscale the activations and reduce their variance in the forward pass, with a more significant reducing effect as the layers get deeper. Intuitively, the marginal utility of adding a new layer decreases with depth. Therefore, for deeper layers, GradInit learns to further downscale the residual branch, and prevents the variance from increasing too much in the forward pass. Inside each residual block, increasing the scale factors of the first BN helps to reduce the magnification effect of the second BN on the gradient; forcing the input activations to the second convolution to have variance larger than 1 ensures its variance after the following convolution layer does not go below 1, avoiding the magnification effect that the second BN has on the gradient variance. See Appendix C for more discussions about the magnifying effect. ",
+        "bbox": [
+            174,
+            869,
+            826,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            826,
+            257
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/a7344c4efa23fb5c2e0f9c33166c671af5c5ac6208c65dc6caf1111ebd4c6b90.jpg",
+        "table_caption": [
+            "Table 4: Comparing the results of GradInit with fixed BN scale parameters (Fix BN) and only rescale the BN parameters (Only BN). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"2\">Kaiming</td><td colspan=\"2\">GradInit</td><td colspan=\"2\">GradInit (Fix BN)</td><td rowspan=\"2\">GradInit (Only BN) Accbest</td></tr><tr><td>Acco</td><td>Accbest</td><td>Acco</td><td>Accbest</td><td>Acco Accbest</td><td>Acco</td></tr><tr><td>VGG-19 (w/ BN)</td><td>12.6 ±0.6 94.4 ± 0.1 47.8 ± 1.8 95.1 ± 0.1 13.1 ± 0.9 94.6 ±0.1 14.4 ± 2.1 94.4 ± 0.1</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>ResNet-110(w/BN) 23.2±0.9 95.0 ±0.2 38.2 ±0.9 95.4 ± 0.1 24.7±3.1 94.7±0.3 25.4±3.1 94.6± 0.3</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            174,
+            303,
+            821,
+            364
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/29ec11160bd9a9835d5c21fe8e79599076b65032c2e6c83a982ce6b3aac72b07.jpg",
+        "table_caption": [
+            "Table 5: Comparing the results with multiplying each weight matrix with a learnable scaler (Learning Scalars) on CIFAR10. The VGG-19 model is not able to converge unless we reduce the initial learning rate to 0.01, which obtained worse final accuracy. The ResNet-110 model’s $A c c _ { 0 }$ was $10 \\%$ for 2 of the 4 runs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td colspan=\"2\">Learning Scalars</td><td colspan=\"2\">GradInit</td></tr><tr><td></td><td>Acco</td><td>Accbest</td><td>Acco</td><td>AcCbest</td></tr><tr><td>VGG-19 (w/BN,Ir=0.1)</td><td>10.0±0.0</td><td></td><td>10.0±0.0 47.8±1.8 95.1±0.1</td><td></td></tr><tr><td>VGG-19 (w/BN,Ir=0.01) 50.6±0.8</td><td></td><td>93.4 ±0.1</td><td></td><td>=</td></tr><tr><td>ResNet-110 (w/BN)</td><td>21.5 ± 6.9</td><td></td><td>94.7 ± 0.1 38.2 ± 0.9 95.4 ± 0.1</td><td></td></tr></table>",
+        "bbox": [
+            285,
+            420,
+            707,
+            494
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Generalizing to Adam. Models in previous experiments are trained with SGD. We also consider the case when $\\mathcal { A }$ is Adam and use AdamW $\\mathbb { \\lVert 3 3 \\rVert }$ to train the ResNet-110 (w/ BN) model on CIFAR-10. Following $\\pmb { \\mathbb { B 4 } }$ , we use a cosine annealing learning rate schedule with initial learning rate $3 \\times 1 0 ^ { - 3 }$ and weight decay 0.2. For GradInit, we set $\\gamma = 2 5$ . The $A c c _ { 1 }$ and $A c c _ { b e s t }$ of Kaiming initialization and GradInit are $( 3 6 . 6 \\pm 4 . 7$ , $9 4 . 9 \\pm 0 . 1 )$ and $( 4 0 . 2 \\pm 0 . 2$ , $9 5 . 3 \\pm 0 . 1 )$ , respectively. We also show the per-epoch test accuracy in Figure 2. ",
+        "bbox": [
+            173,
+            507,
+            825,
+            593
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The importance of rescaling BN layers. The scale parameters of BN layers usually controls the variance of activations and gradients in the forward and backward passes, while the linear layers right before the BN layers are scale-invariant. Although changing the magnitudes of the scale-invariant layers affect their learning dynamics $\\mathbb { \\left| \\sum 3 \\right| \\left| \\sum 4 \\right| }$ , we find it important for GradInit to rescale both BN and other linear layers, as shown in Table 4. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            667
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The importance of GradInit’s objective. GradInit is designed to rescale the layers to solve the constrained optimization problem in Eq. $^ { 1 . }$ Simply letting the model to learn to rescale the layers cannot improve the results, and sometimes further causes instability, as shown in Table $5 .$ We hypothesize that the bad results with VGG are due to a mismatch between the scales/norms of the gradients of the scalars and the weights. To make this alternative work, we may need to set different learning rates for the scalars and the weights, which adds to the difficulty of hyperparameter tuning. Note we do not learn the scalars when training networks initialized by GradInit. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            770
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e627993923a4a1da1865e96757438d4905377349420a3104d24a2cad4ee3cb08.jpg",
+        "table_caption": [
+            "Table 6: $A c c _ { 1 } / A c c _ { b e s t }$ of ResNet-50 models on ImageNet. Result of MetaInit comes from Dauphin and Schoenholz $[ [ 1 6 ] ]$ and we reimplemented the rest. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Kaiming</td><td>FixUp</td><td>MetaInit</td><td>GradInit</td></tr><tr><td>w/BN</td><td>14.6/75.9</td><td>1</td><td>-</td><td>19.2/76.2</td></tr><tr><td>w/o BN</td><td>1</td><td>18.0/75.7</td><td>-/75.4</td><td>19.2/75.8</td></tr></table>",
+        "bbox": [
+            318,
+            816,
+            676,
+            869
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "GradInit scales to ImageNet. As shown in Table $6 ,$ GradInit also accelerates convergence and improves test accuracy of ResNet-50 on ImageNet, with or without BN layers, despite having to use a smaller batch size for GradInit than training due to our GPU memory limit. The acceleration achieved by GradInit is even more significant than FixUp, even on the network with the architecture designed for the initialization. ",
+        "bbox": [
+            173,
+            882,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2 Training the Original Transformer Model without Warmup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            154,
+            627,
+            169
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For a Transformer model to converge, either an explicit or implicit learning rate warmup stage is needed, especially for the original Transformer architecture. It is observed that this Post-LN architecture tends to outperform the Pre-LN model $\\textcircled { 6 }$ while having higher gradient variance at initialization [4]. Is it believed that this high variance makes a warmup stage inevitable. Previous works that removes the warmup stage often involves architectural changes, e.g., removing Layer Normalizations, since it can surprisingly cause instability [4]. Here, we show that with a proper initialization, we can do away with the warmup stage for the original Post-LN Transformer without any modification to the architecture. Table 7 summarizes the architectural changes and best results of methods for improving the initialization of Post-LN Transformers. We compare the stability of the GradInit and Admin initialization methods without warmup in Figure 3. ",
+        "bbox": [
+            173,
+            181,
+            825,
+            320
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/4ba7083f0ada1dae6e6311735f433cdc22ee4666313066d623f76bf7b2dca4ce.jpg",
+        "table_caption": [
+            "Table 7: A comparison of GradInit with with the results from the papers (top 4 rows), and our reimplementation of Admin for training the Post-LN Transformer model on the IWSLT-14 De-EN dataset. “Standard\" refers to training with standard initialization and warmup. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Remove LN</td><td>Wskip</td><td>Warmup</td><td>Optimizer</td><td>BLEU</td></tr><tr><td>Standard [6</td><td></td><td></td><td>√</td><td>RAdam</td><td>35.6</td></tr><tr><td>FixUp 回</td><td>√</td><td></td><td>√</td><td>Adam</td><td>34.5</td></tr><tr><td>T-FixUp[5]</td><td></td><td></td><td></td><td>Adam</td><td>35.5</td></tr><tr><td>Admin 回</td><td></td><td>√</td><td></td><td>RAdam</td><td>35.7</td></tr><tr><td>Admin</td><td></td><td>√</td><td></td><td>Adam</td><td>36.1</td></tr><tr><td>Admin</td><td></td><td>√</td><td></td><td>SGD</td><td>33.7</td></tr><tr><td>GradInit</td><td></td><td>√</td><td></td><td>Adam</td><td>36.0</td></tr><tr><td>GradInit</td><td></td><td></td><td></td><td>Adam</td><td>36.1</td></tr><tr><td>GradInit</td><td></td><td></td><td></td><td>SGD</td><td>35.6</td></tr></table>",
+        "bbox": [
+            269,
+            382,
+            723,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dataset, Architecture, & Hyperparameters. ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            550,
+            478,
+            565
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "IWSLT’14 DE-EN $\\pmb {  \\pmb {   2 8  }  }$ is a German to English translation dataset that has $1 6 0 \\mathrm { k }$ training examples. Our Transformer model is inherited from $\\mathbf { \\widehat { \\mathbb { B } } }$ , which is a Post-LN Transformer placing its Layer Normalization after the summation of the skip connection and the residual branch. It has a 512- dimensional word embedding layer and 1024 dimensions in its hidden FFN layer. We also apply GradInit to the variant from Admin $\\textcircled { 6 }$ , where a learnable vector ${ { \\pmb w } _ { s k i p } }$ is element-wise multiplied with each dimension of the skip connection, but we initialize it to 1 for GradInit. Please refer to $\\dot { \\left. \\left[ 6 \\right] \\right. }$ for how Admin initializes these weights. Following $\\textcircled { 6 }$ , we use a linearly decaying learning rate schedule that decays from the maximum learning rate $\\eta _ { \\mathrm { m a x } }$ to 0 as the model trains for 100K iterations. For training with SGD, we set the prescribed learning rate $\\eta _ { \\mathrm { m a x } } = 0 . 1 5$ , and use $\\eta = 0 . 1 5 , \\gamma = 1$ for GradInit. We do a grid search on $\\eta _ { \\mathrm { m a x } }$ for Admin and report its best result in Table $\\perp$ For training with Adam, we set $\\dot { \\eta } = 5 \\times 1 0 ^ { - 4 } , \\dot { \\gamma } = 1 0 ^ { 3 }$ for the objective of GradInit, so that $\\eta \\gamma$ is $O ( 1 0 ^ { - 1 } )$ as discussed in Section 3.3. We train the initialized model $\\eta _ { \\mathrm { m a x } }$ and $\\beta _ { 2 }$ as listed in Figure $3 .$ We evaluate the BLEU score every epoch, and report the best BLEU scores throughout training for each run. For GradInit, we set the maximum number of iterations $T$ to 780. By comparison, the warmup stage usually takes 4000 iterations, and we find that if we use 780 steps for warmup, the model does not converge with $\\eta _ { \\mathrm { m a x } } \\ge 3 \\times 1 0 ^ { - 4 }$ . For $\\eta _ { \\mathrm { m a x } } = 2 \\times 1 0 ^ { - 4 }$ with 780-step warmup, the BLEU score is 35.4, worse than GradInit’s 36.0, showing the advantage of GradInit against warmup. ",
+        "bbox": [
+            173,
+            571,
+            825,
+            806
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Stability after removing warmup for Adam. In Figure $\\boxed { 3 }$ , the training process becomes more unstable as $\\beta _ { 2 }$ grows larger. From the analysis of RAdam $[ \\overbrace { 3 5 } ] ]$ , this is because the variance of the gradient has a stronger impact on the adaptive learning rate when $\\beta _ { 2 }$ is closer to 1. Therefore, the largest $\\beta _ { 2 } < 1$ that maintains the performance of the trained model reflects the stability of the initialization. We can see GradInit results in more stable models than Admin in general, though their best performance numbers are almost the same. In addition, we find ${ { \\pmb w } _ { s k i p } }$ can help stabilize training in extreme hyper parameter settings, e.g., at $\\eta _ { \\mathrm { m a x } } = 5 \\times 1 0 ^ { - 4 }$ and $\\beta _ { 2 } = 0 . 9 9 5$ in Figure $\\bigtriangledown _ { \\ b { \\lambda } }$ GradInit with ${ { \\pmb w } _ { s k i p } }$ obtains a good average BLEU score of 36.0, while without ${ { \\pmb w } _ { s k i p } }$ only succeeded in obtaining a BLEU score $> 3 5$ for one out of four experiments, resulting in an average BLEU score of 8.9. ",
+        "bbox": [
+            174,
+            813,
+            825,
+            912
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We also find the network is unable to be trained without learning rate warmup if we just fix ${ { \\pmb w } _ { s k i p } }$ to its initial value given by Admin and leave the initialization of other parameters unchanged. Nevertheless, with GradInit, we do not need to modify the architecture of Post-LN Transformer to obtain the same good result as Admin. For a closer look at the stabilization mechanism, we show the weight norms and gradient variance at initialization of the original Post-LN architecture using GradInit and Xavier initialization in Figure 9 of the Appendix. For Xavier initialization, the gradient variance is relatively higher for all encoder layers, so GradInit downscales the encoder layer weights more in general. For the LN weights, GradInit only ",
+        "bbox": [
+            174,
+            119,
+            485,
+            339
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/54b16b400c864897eac4effa71200cc1009e90a3c1eecd924677164f4aecc148.jpg",
+        "image_caption": [
+            "Figure 3: BLEU scores for the Post-LN Transformer without learning rate warmup using Adam on IWSLT-14 DE-EN under different learning rates $\\eta _ { \\mathrm { m a x } }$ ( $y$ axis) and $\\beta _ { 2 }$ $x$ axis). Each result is averaged over 4 experiments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            501,
+            138,
+            820,
+            247
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "downscales the final LN of both the encoder and decoder, which reduces the variance of the encoder and decoder during the forward pass. Another strategy GradInit learns is to downscale the weights of the output projection and the FFN layers, so that the residual branch is relatively down-weighted compared with the skip connection, similar to Admin. ",
+        "bbox": [
+            174,
+            339,
+            826,
+            395
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Removing warmup without architectural change. Another widely observed phenomenon is that adaptive methods such as Adam seem to be much better than SGD for training Transformer-based language models [13]. Table 7 shows that, with GradInit, we can find a good initialization for the Post-LN Transformer on IWSLT-14 DE-EN that trains using SGD without learning rate warmup nor gradient clipping, and achieves performance close to Adam trained using the same type of learning rate schedule. By comparison, Admin also makes the Transformer trainable with SGD, but the BLEU score is lower than the one initialized with GradInit. By comparing Figures 9 and $1 0$ in the Appendix, we find GradInit for Adam and SGD adopts different rescaling patterns, with the Adam version depending more on downscaling the residual branches through the FFN and output projection layers than the SGD version, and the SGD version downscaling more in the final FFN block of the decoder. This highlights the importance of considering the optimization algorithm $\\mathcal { A }$ in GradInit, and also indicates the presence of different ways to reduce the initial gradient variance. ",
+        "bbox": [
+            173,
+            401,
+            825,
+            566
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            593,
+            297,
+            609
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose GradInit, a gradient-based initialization scheme for any architecture. GradInit reinitializes a network by learning a scale factor for each randomly initialized parameter block of a network, so that the training loss evaluated on a different minibatch after one gradient step of a specific stochastic optimizer is minimized. Such a design takes the stochasticity, the learning rate, and the direction of the optimizer into account, allowing us to find better initializations tailored for the optimizer. The initialization learned by GradInit often decreases the gradient variance for most of the parameter blocks. We show that GradInit accelerates the convergence and improves the test performance of a variety of architectures on image classification. It also enables training the Post-LN Transformer without any form of learning rate warmup, even for SGD. GradInit can be a useful tool in the future discovery of better neural architectures that are otherwise discarded due to poor initializations. By analyzing the learned scaling coefficients and their impact on gradient variance, it can also serve a guide to design better initialization schemes for complex architectures to shorten the training schedule and save energy. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            808
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Acknowledgement ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            833,
+            357,
+            851
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This project was supported by the Office of Naval Research, AFOSR MURI program, the DARPA Young Faculty Award, and the National Science Foundation Division of Mathematical Sciences. Additional support was provided by Capital One Bank and JP Morgan Chase. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In AISTATS, 2010.   \n[2] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In CVPR, 2015.   \n[3] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, pages 5998–6008, 2017.   \n[4] Ruibin Xiong, Yunchang Yang, Di He, Kai Zheng, Shuxin Zheng, Chen Xing, Huishuai Zhang, Yanyan Lan, Liwei Wang, and Tieyan Liu. On layer normalization in the transformer architecture. In ICML, 2020.   \n[5] Xiao Shi Huang, Felipe Perez, Jimmy Ba, and Maksims Volkovs. Improving transformer optimization through better initialization. In ICML, 2020.   \n[6] Liyuan Liu, Xiaodong Liu, Jianfeng Gao, Weizhu Chen, and Jiawei Han. Understanding the difficulty of training transformers. EMNLP, 2020.   \n[7] Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019.   \n[8] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. NeurIPS, 2020.   \n[9] Hongyi Zhang, Yann N Dauphin, and Tengyu Ma. Fixup initialization: Residual learning without normalization. In ICLR, 2019.   \n[10] Soham De and Sam Smith. Batch normalization biases residual blocks towards the identity function in deep networks. NeurIPS, 2020.   \n[11] Andrew Brock, Soham De, and Samuel L Smith. Characterizing signal propagation to close the performance gap in unnormalized resnets. ICLR, 2021.   \n[12] Andrew Brock, Soham De, Samuel L. Smith, and Karen Simonyan. High-performance largescale image recognition without normalization. arXiv preprint arXiv:2102.06171, 2021.   \n[13] Jingzhao Zhang, Sai Praneeth Karimireddy, Andreas Veit, Seungyeon Kim, Sashank J Reddi, Sanjiv Kumar, and Suvrit Sra. Why are adaptive methods good for attention models? NeurIPS, 2020.   \n[14] Andrew M Saxe, James L McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. ICLR, 2014.   \n[15] Dmytro Mishkin and Jiri Matas. All you need is a good init. ICLR, 2016.   \n[16] Yann N Dauphin and Samuel Schoenholz. Metainit: Initializing learning by learning to initialize. In NeurIPS, pages 12645–12657, 2019.   \n[17] Mert Gurbuzbalaban and Yuanhan Hu. Fractional moment-preserving initialization schemes for training deep neural networks. In International Conference on Artificial Intelligence and Statistics, pages 2233–2241. PMLR, 2021.   \n[18] Charles H Martin and Michael W Mahoney. Traditional and heavy-tailed self regularization in neural network models. arXiv preprint arXiv:1901.08276, 2019.   \n[19] Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, pages 448–456, 2015.   \n[20] Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.   \n[21] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pages 770–778, 2016.   \n[22] Thomas Bachlechner, Bodhisattwa Prasad Majumder, Huanru Henry Mao, Garrison W Cottrell, and Julian McAuley. Rezero is all you need: Fast convergence at large depth. arXiv preprint arXiv:2003.04887, 2020.   \n[23] Sanjeev Arora, Zhiyuan Li, and Kaifeng Lyu. Theoretical analysis of auto rate-tuning by batch normalization. In International Conference on Learning Representations, 2019.   \n[24] Ruosi Wan, Zhanxing Zhu, Xiangyu Zhang, and Jian Sun. Spherical motion dynamics of deep neural networks with batch normalization and weight decay. arXiv preprint arXiv:2006.08419, 2020.   \n[25] Lukas Balles and Philipp Hennig. Dissecting adam: The sign, magnitude and variance of stochastic gradients. In ICML, pages 404–413, 2018.   \n[26] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.   \n[27] J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR, 2009.   \n[28] Mauro Cettolo, Jan Niehues, Sebastian Stüker, Luisa Bentivogli, and Marcello Federico. Report on the 11th iwslt evaluation campaign, iwslt 2014. In IWSLT, volume 57, 2014.   \n[29] Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, and Michael Auli. fairseq: A fast, extensible toolkit for sequence modeling. In NAACL-HLT (Demonstrations), 2019.   \n[30] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2015.   \n[31] Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint arXiv:1608.03983, 2016.   \n[32] Priya Goyal, Piotr Dollár, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.   \n[33] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations, 2018.   \n[34] Chen Zhu, Yu Cheng, Zhe Gan, Furong Huang, Jingjing Liu, and Tom Goldstein. Maxva: Fast adaptation of step sizes by maximizing observed variance of gradients. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pages 628–643. Springer, 2021.   \n[35] Liyuan Liu, Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Jiawei Han. On the variance of the adaptive learning rate and beyond. ICLR, 2020.   \n[36] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.   \n[37] Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.   \n[38] Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In CVPR, 2017.   \n[39] Terrance DeVries and Graham W Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017.   \n[40] Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. ICLR, 2018.   \n[41] Jeremy Bernstein, Yu-Xiang Wang, Kamyar Azizzadenesheli, and Animashree Anandkumar. signsgd: Compressed optimisation for non-convex problems. In ICML, 2018. ",
+        "bbox": [
+            171,
+            80,
+            828,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            71,
+            828,
+            912
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            130
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] One limitation of our current work is we have not checked whether GradInit can improve the training of models from other domains such as speech.   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            253
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            257,
+            493,
+            272
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            236,
+            276,
+            736,
+            308
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            311,
+            393,
+            327
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] ",
+        "bbox": [
+            238,
+            330,
+            825,
+            449
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            217,
+            453,
+            823,
+            468
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [Yes]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            472,
+            825,
+            593
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            598,
+            705,
+            612
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            616,
+            825,
+            705
+        ],
+        "page_idx": 12
+    }
+]