Add files using upload-large-folder tool

parse/train/B1MIBs05F7/B1MIBs05F7.md

@@ -0,0 +1,258 @@
+# ON THE INEFFECTIVENESS OF VARIANCE REDUCED OPTIMIZATION FOR DEEP LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+The application of stochastic variance reduction to optimization has shown remarkable recent theoretical and practical success. The applicability of these techniques to the hard non-convex optimization problems encountered during training of modern deep neural networks is an open problem. We show that naive application of the SVRG technique and related approaches fail, and explore why.
+
+# 1 INTRODUCTION
+
+Stochastic variance reduction (SVR) consists of a collection of techniques for the minimization of finite-sum problems:
+
+$$
+\begin{array} { r } { f ( w ) = \frac { 1 } { n } \sum _ { i = 1 } ^ { N } f _ { i } ( w ) , } \end{array}
+$$
+
+such as those encountered in empirical risk minimization, where each $f _ { i }$ is the loss on a single training data point. Principle techniques include SVRG (Johnson & Zhang, 2013), SAGA (Defazio et al., 2014a), and their variants. SVR methods use control variates to reduce the variance of the traditional stochastic gradient descent (SGD) estimate $f _ { i } ^ { \prime } ( w )$ of the full gradient $f ^ { \prime } ( w )$ . Control variates are a classical technique for reducing the variance of a stochastic quantity without introducing bias. Say we have some random variable $X$ . Although we could use $X$ as an estimate of $E [ X ] = { \bar { X } }$ , we can often do better through the use of a control variate $Y$ . If $Y$ is a random variable correlated with $X$ (i.e. $\mathrm { C o v } [ X , Y ] > 0 $ ), then we can estimate $\bar { X }$ with the quantity
+
+$$
+Z = X - Y + E [ Y ] .
+$$
+
+This estimate is unbiased since $- Y$ cancels with $E [ Y ]$ when taking expectations, leaving $E [ Z ] =$ $E [ X ]$ . As long as $V a r [ Y ] \leq 2  { \mathrm { C o v } } [ X , Y ]$ , the variance of $Z$ is lower than that of $X$ .
+
+Remarkably, these methods are able to achieve linear convergence rates for smooth strongly-convex optimization problems, a significant improvement on the sub-linear rate of SGD. SVR methods are part of a larger class of methods that explicitly exploit finite-sum structures, either by dual (SDCA, Shalev-Shwartz & Zhang, 2013; MISO, Mairal, 2014; Finito, Defazio et al., 2014b) or primal (SAG, Schmidt et al., 2017) approaches.
+
+Recent work has seen the fusion of acceleration with variance reduction (Shalev-Shwartz & Zhang (2014); Lin et al. (2015); Defazio (2016); Allen-Zhu (2017)), and the extension of SVR approaches to general non-convex (Allen-Zhu & Hazan, 2016; Reddi et al., 2016) as well as saddle point problems (Balamurugan & Bach, 2016).
+
+In this work we study the behavior of variance reduction methods on a prototypical non-convex problem in machine learning: A deep convolutional neural network designed for image classification. We discuss in Section 2 how standard training and modeling techniques significantly complicate the application of variance reduction methods in practice, and how to overcome some of these issues. In Sections 3 & 5 we study empirically the amount of variance reduction seen in practice on modern CNN architectures, and we quantify the properties of the network that affect the amount of variance reduction. In Sections 6 & 7 we show that streaming variants of SVRG do not improve over regular SVRG despite their theoretical ability to handle data augmentation. In Section 8 we study properties of DNN problems that actually give stochastic gradient descent an advantage over variance reduction techniques.
+
+# STANDARD SVR APPROACH
+
+The SVRG method is the simplest of the variance reduction approaches to apply for large-scale problems, so we will focus our initial discussion on it. In SVRG, training epochs are interlaced with snapshot points where a full gradient evaluation is performed. The iterate at the snapshot point $\tilde { w }$ is stored, along with the full gradient $f ^ { \prime } ( \tilde { w } )$ . Snapshots can occur at any interval, although once per epoch is the most common frequency used in practice. The SGD step $w _ { k + 1 } = w _ { k } - \gamma f _ { i } ^ { \prime } ( w _ { k } )$ , using the randomly sampled data-point loss $f _ { i }$ with step size $\gamma$ , is augmented with the snapshot gradient using the control variate technique to form the SVRG step:
+
+$$
+w _ { k + 1 } = w _ { k } - \gamma \left[ f _ { i } ^ { \prime } ( w _ { k } ) - f _ { i } ^ { \prime } ( \tilde { w } ) + f ^ { \prime } ( \tilde { w } ) \right] .
+$$
+
+The single-data point gradient $f _ { i } ^ { \prime } ( \tilde { w } )$ may be stored during the snapshot pass and retrieved, or recomputed when needed. The preference for recomputation or storage depends a lot on the computer architecture and its bottlenecks, although recomputation is typically the most practical approach.
+
+Notice that following the control variate approach, the expected step, conditioning on $w _ { k }$ , is just a gradient step. So like SGD, it is an unbiased step. Unbiasedness is not necessary for the fast rates obtainable by SVR methods, both SAG (Schmidt et al., 2017) and Point-SAGA (Defazio, 2016) use biased steps, however biased methods are harder to analyze. Note also that successive step directions are highly correlated, as the $f ^ { \prime } ( \tilde { w } )$ term appears in every consecutive step between snapshots. This kind of step correlation is also seen in momentum methods, and is considered a contributing factor to their effectiveness (Kidambi et al., 2018).
+
+# 2 COMPLICATIONS IN PRACTICE
+
+Modern approaches to training deep neural networks deviate significantly from the assumptions that SVR methods are traditionally analyzed under. In this section we discuss the major ways in which practice deviates from theory and how to mitigate any complications that arise.
+
+# DATA AUGMENTATION
+
+In order to achieve state-of-the-art results in most domains, data augmentation is essential. The standard approach is to form a class of transform functions $\tau$ ; for an image domain typical transforms include cropping, rotation, flipping and compositions thereof. Before the gradient calculation for a data-point $x _ { i }$ , a transform $T _ { i }$ is sampled and the gradient is evaluated on its image $T _ { i } ( x _ { i } )$ .
+
+When applying standard SVRG using gradient recomputation, the use of random transforms can destroy the prospects of any variance reduction if different transforms are used for a datapoint during the snapshot pass compared to the following steps. Using a different transform is unfortunately the most natural implementation
+
+![](images/039b79a0d535a263c8eac581f288d7980e7962dbafcf0015cee9947e419b83ee.jpg)  
+Figure 1: Variance within epoch two during LeNet training on CIFAR10.
+
+when using standard libraries (PyTorch1; TensorFlow, Abadi et al. (2015)), as the transform is applied automatically as part of the data-pipeline. We propose the use of transform locking, where the transform used during the snapshot pass is cached and reused during the following epoch/s.
+
+This performance difference is illustrated in Figure 1, where the variance of the SVRG step is compared with and without transform locking during a single epoch during training of a LeNet model. Data augmentation consisted of random horizontal flips and random cropping to $3 2 \mathbf { x } 3 2$ , after padding by 4 pixels on each side (following standard practice).
+
+For SVRG with transform locking, the variance of the step is initially zero at the very beginning of the epoch, increasing over the course of the epoch. This is the behavior expected of SVRG on finite sum problems. In contrast, without transform locking the variance is non-zero at the beginning of the epoch, and uniformly worse.
+
+The handling of data augmentation in finite-sum methods has been previously considered for the MISO method (Bietti & Mairal, 2017), which is one of the family of gradient table methods (as with the storage variant of SVRG). The stored gradients are updated with an exponential moving average instead of overwriting, which averages over multiple past transformed-data-point gradients. As we show in Section 5, stored gradients can quickly become too stale to provide useful information when training large models.
+
+# BATCH NORMALIZATION
+
+Batch normalization (Ioffe & Szegedy, 2015) is another technique that breaks the finite-sum structure assumption. In batch normalization, mean and variance statistics are calculated within a minibatch, for the activations of each layer (typically before application of a nonlinearity). These statistics are used to normalize the activations. The finite sum structure no longer applies since the loss on a datapoint $i$ depends on the statistics of the mini-batch it is sampled in.
+
+The interaction of BN with SVRG depends on if storage or recomputation of gradients is used. When recomputation is used naively, catastrophic divergence occurs in standard frameworks. The problem is a subtle interaction with the internal computation of running means and variances, for use at test time.
+
+In order to apply batch normalization at test time, where data may not be mini-batched or may not have the same distribution as training data, it is necessary to store mean and variance information at training time for later use. The standard approach is to keep track of a exponential moving average of the mean and variances computed at each training step. For instance, PyTorch by default will update the moving average $m _ { E M A }$ using the mini-batch mean $m$ as:
+
+$$
+m _ { E M A } = \frac { 9 } { 1 0 } m _ { E M A } + \frac { 1 } { 1 0 } m .
+$$
+
+During test time, the network is switched to evaluation mode using model.eval(), and the stored running mean and variances are then used instead of the internal mini-batch statistics for normalization. The complication with SVRG is that during training the gradient evaluations occur both at the current iterate $x _ { k }$ and the snapshot iterate $\tilde { x }$ . If the network is in train mode for both, the EMA will average over activation statistics between two different points, resulting in poor results and divergence.
+
+Switching the network to evaluation mode mid-step is the obvious solution, however computing the gradient using the two different sets of normalizations results in additional introduced variance. We recommend a BN reset approach, where the normalization statistics are temporarily stored before the $\tilde { w }$ gradient evaluation, and the stored statistics are used to undo the updated statistics by overwriting afterwards. This avoids having to modify the batch normalization library code. It is important to use train mode during the snapshot pass as well, so that the mini-batch statistics match between the two evaluations.
+
+# DROPOUT
+
+Dropout (Srivastava et al., 2014) is another popular technique that affects the finite-sum assumption. When dropout is in use, a random fraction, usually $50 \%$ , of the activations will be zero at each step. This is extremely problematic when used in conjunction with variance reduction, since the sparsity pattern will be different for the snapshot evaluation of a datapoint compared to its evaluation during the epoch, resulting in much lower correlation and hence lower variance reduction.
+
+The same dropout pattern can be used at both points as with the transform locking approach proposed above. The seed used for each data-point’s sparsity pattern should be stored during the snapshot pass, and reused during the following epoch when that data-point is encountered. Storing the sparsity patterns directly is not practical as it will be many times larger than memory even for simple models.
+
+Residual connection architectures benefit very little from dropout when batch-norm is used (He et al., 2016; Ioffe & Szegedy, 2015), and because of this we don’t use dropout in the experiments detailed in this work, following standard practice.
+
+# ITERATE AVERAGING
+
+Although it is common practice to use the last iterate of an epoch as the snapshot point for the next epoch, standard SVRG theory requires computing the snapshot at either an average iterate or a randomly chosen iterate from the epoch instead. Averaging is also needed for SGD when applied to non-convex problems. We tested both SVRG and SGD using averaging of $100 \%$ , $50 \%$ or $10 \%$ of the tail of each epoch as the starting point of the next epoch. Using a $10 \%$ tail average did result in faster initial convergence for both methods before the first step size reduction on the CIFAR10 test problem (detailed in the next section). However, this did not lead to faster convergence after the first step size reduction, and final test error was consistently worse than without averaging. For this reason we did not use iterate averaging in the experiments presented in this work.
+
+# 3 MEASURING VARIANCE REDUCTION
+
+To illustrate the degree of variance reduction achieved by SVRG on practical problems, we directly computed the variance of the SVRG gradient estimate, comparing it to the variance of the stochastic gradient used by SGD. To minimize noise the variance was estimated using the full dataset. The transform locking and batch norm reset techniques described above were used in order to get the most favorable performance out of SVRG.
+
+Ratios below one indicate that variance reduction is occurring, whereas ratios around two indicate that the control variate is uncorrelated with the stochastic gradient, leading to an increase in variance. For SVRG to be effective we need a ratio below $1 / 3$ to offset the additional computational costs of the method. We plot the variance ratio at multiple points within each epoch as it changes significantly during each epoch. An initial step size of 0.1 was used, with 10-fold decreases at 150 and 220 epochs. A batch size of 128 with momentum 0.9 was used for all methods.
+
+To highlight differences introduced by model complexity, we compared four models:
+
+1. The classical LeNet-5 model (Lecun et al., 1998), modified to use batch-norm and ReLUs, with approximately 62 thousand parameters2.   
+2. A ResNet-18 model (He et al., 2016), scaled down to match the model size of the LeNet model by halving the number of feature planes at each layer. It has approximately 69 thousand parameters.   
+3. A ResNet-110 model with $1 . 7 \mathrm { m }$ parameters, as used by He et al. (2016).   
+4. A wide DenseNet model (Huang et al., 2017) with growth rate 36 and depth 40. It has approximately 1.5 million parameters and achieves below $5 \%$ test error.
+
+Figure 2 shows how this variance ratio depends dramatically on the model used. For the LeNet model, the SVRG step has consistently lower variance, from $4 \mathbf { x }$ to $2 \mathbf { x }$ depending on the position within the epoch, during the initial phase of convergence.
+
+In contrast, the results for the DenseNet-40-36 model as well as the ResNet-110 model show an increase in variance, for the majority of each epoch, up until the first step size reduction at epoch 150. Indeed, even at only $2 \%$ progress through each epoch, the variance reduction is only a factor of 2, so computing the snapshot pass more often than once an epoch can not help during the initial phase of optimization.
+
+The small ResNet model sits between these two extremes, showing some variance reduction midepoch at the early stages of optimization. Compared to the LeNet model of similar size, the modern architecture with its greater ability to fit the data also benefits less from the use of SVRG.
+
+# 4 SNAPSHOT INTERVALS
+
+The number of stochastic steps between snapshots has a significant effect on the practical performance of SVRG. In the classical convex theory the interval should be proportional to the condition number (Johnson & Zhang, 2013), but in practice an interval of one epoch is commonly used, and that is what we used in the experiment above. A careful examination of our results from Figure 2
+
+![](images/6c43addcbbbe54847f10581970302758718e19526d1c74a18b82ffe1ebbc373b.jpg)  
+Figure 2: The SVRG to SGD gradient variance ratio during a run of SVRG. The shaded region indicates a variance increase, where the SVRG variance is worse than the SGD baseline. Dotted lines indicate when the step size was reduced. The variance ratio is shown at different points within each epoch, so that the $2 \%$ dots (for instance) indicate the variance at 1,000 data-points into the 50,000 datapoints consisting of the epoch. Multiple percentages within the same run are shown at equally spaced epochs.
+
+SVRG fails to show a variance reduction for the majority of each epoch when applied to modern high-capacity networks, whereas some variance reduction is seem for smaller networks.
+
+show that no adjustment to the snapshot interval can salvage the method. The SVRG variance can be kept reasonable (i.e. below the SGD variance) by reducing the duration between snapshots, however for the ResNet-110 and DenseNet models, even at $11 \%$ into an epoch, the SVRG step variance is already larger than that of SGD, at least during the crucial 10-150 epochs. If we were to perform snapshots at this frequency the wall-clock cost of the SVRG method would go up by an order of magnitude compared to SGD, while still under-performing on a per-epoch basis.
+
+Similarly, we can consider performing snapshots at less frequent intervals. Our plots show that the variance of the SVRG gradient estimate will be approximately $2 \mathbf { x }$ the variance of the SGD estimate on the harder two problems in this case (during epochs 10-150), which certainly will not result in faster convergence. This is because the correction factor in Equation 1 becomes so out-of-date that it becomes effectively uncorrelated with the stochastic gradient, and since it’s magnitude is comparable (the gradient norm decays relatively slowly during optimization for these networks) adding it to the stochastic gradient results in a doubling of the variance.
+
+# 4.1 VARIANCE REDUCTION AND OPTIMIZATION SPEED
+
+For sufficiently well-behaved objective functions (such as smooth & strongly convex), we can expect that an increase of the learning rate results in a increase of the converge rate, up until the learning rate approaches a limit defined by the curvature $( \approx 1 / L$ for $\mathrm { L }$ Lipschitz-smooth functions). This holds also in the stochastic case for small learning rates, however there is an additional ceiling that occurs as you increase the learning rate, where the variance of the gradient estimate begins to slow convergence. Which ceiling comes into effect first determines if a possible variance reduction (such as from SVRG) can allow for larger learning rates and thus faster convergence. Although clearly a simplified view of the non-differentiable non-convex optimization problem we are considering, it still offers some insight.
+
+![](images/ac068d351d4a05aef0bb4416f00340b1da13080b46f98c0d1e7947cfd0fac601.jpg)  
+Figure 3: Distance moved from the snapshot point, and curvature relative to the snapshot point, at epoch 50.
+
+Empirically deep residual networks are known to be constrained by the curvature for a few initial epochs, and afterwards are constrained by the variance. For example, Goyal et al. (2017) show that decreasing the variance by increasing the batch-size allows them to proportionally increase the learning rate for variance reduction factors up to 30 fold. This is strong evidence that a SVR technique that results in significant variance reduction can potentially improve convergence in practice.
+
+# 5 WHY VARIANCE REDUCTION FAILS
+
+Figure 2 clearly illustrates that for the DenseNet model, SVRG gives no actual variance reduction for the majority of the optimization run. This also holds for larger ResNet models (plot omitted). The variance of the SVRG estimator is directly dependent on how similar the gradient is between the snapshot point $\tilde { x }$ and the current iterate $x _ { k }$ . Two phenomena may explain the differences seen here. If the $w _ { k }$ iterate moves too quickly through the optimization landscape, the snapshot point will be too out-of-date to provide meaningful variance reduction. Alternatively, the gradient may just change more rapidly in the larger model.
+
+Figure 3 sheds further light on this. The left plot shows how rapidly the current iterate moves within the same epoch for LeNet and DenseNet models when training using SVRG. The distance moved from the snapshot point increases significantly faster for the DenseNet model compared to the LeNet model.
+
+In contrast the right plot shows the curvature change during an epoch, which we estimated as:
+
+$$
+\begin{array} { r } { \Big \| \frac { 1 } { | S _ { i } | } \sum _ { j \in S _ { i } } \left[ f _ { j } ^ { \prime } ( w _ { k } ) - f _ { j } ^ { \prime } ( \tilde { w } ) \right] \Big \| / \| w _ { k } - \tilde { w } \| , } \end{array}
+$$
+
+where $S _ { i }$ is a sampled mini-batch. This can be seen as an empirical measure of the Lipschitz smoothness constant. Surprisingly, the measured curvature is very similar for the two models, which supports the idea that iterate distance is the dominating factor in the lack of variance reduction. The curvature is highest at the beginning of an epoch because of the lack of smoothness of the objective (the Lipschitz smoothness is potentially unbounded for non-smooth functions).
+
+Several papers have show encouraging results when using SVRG variants on small MNIST training problems (Johnson & Zhang, 2013; Lei et al., 2017). Our failure to show any improvement when using SVRG on larger problems should not be seen as a refutation of their results. Instead, we believe it shows a fundamental problem with MNIST as a baseline for optimization comparisons. Particularly with small neural network architectures, it is not representative of harder deep learning training problems.
+
+# 5.1 SMOOTHNESS
+
+Since known theoretical results for SVRG apply only to smooth objectives, we also computed the variance when using the ELU activation function (Clevert et al., 2016), a popular smooth activation that can be used as a drop-in replacement for ReLU. We did see a small improvement in the degree
+
+of variance reduction when using the ELU. There was still no significant variance reduction on the DenseNet model.
+
+# 6 STREAMING SVRG VARIANTS
+
+In Section 3, we saw that the amount of variance reduction quickly diminished as the optimization procedure moved away from the snapshot point. One potential fix is to perform snapshots at finer intervals. To avoid incurring the cost of a full gradient evaluation at each snapshot, the class of streaming SVRG (Frostig et al., 2015; Lei et al., 2017) methods instead use a mega-batch to compute the snapshot point. A mega-batch is typically 10-32 times larger than a regular mini-batch. To be precise, let the mini-batch size be $b$ be and the mega-batch size be $B$ . Streaming SVRG alternates between computing a snapshot mega-batch gradient $\tilde { g }$ at $\tilde { w } = w _ { k }$ , and taking a sequence of SVRG inner loop steps where a mini-batch $S _ { k }$ is sampled, then a step is taken:
+
+$$
+w _ { k + 1 } = w _ { k } - \gamma \left[ \frac { 1 } { n } \sum _ { i \in S _ { k } } \left( f _ { i } ^ { \prime } ( w _ { k } ) - f _ { i } ^ { \prime } ( \tilde { w } ) \right) + \tilde { g } \right] .
+$$
+
+Although the theory suggests taking a random number of these steps, often a fixed $m$ steps is used in practice.
+
+In this formulation the data-points from the mega-batch and subsequent $m$ steps are independent. Some further variance reduction is potentially possible by sampling the mini-batches for the inner step from the mega-batch, but at the cost of some bias. This approach has been explored as the Stochastically Controlled Stochastic Gradient (SCSG) method (Lei & Jordan, 2017).
+
+To investigate the effectiveness of streaming SVRG methods we produced variance-overtime plots. We look at the variance of each individual step after the computation of a megabatch, where our mega-batches were taken as $1 0 \mathrm { x }$ larger than our mini-batch size of $1 2 8 ~ \mathrm { C I } -$ FAR10 instances, and 10 inner steps were taken per snapshot. The data augmentation and batch norm reset techniques from Section 2 were used to get the lowest variance possible. The variance is estimated using the full dataset at each point.
+
+Figure 4 shows the results at the beginning of the 50th epoch. In both cases the variance is reduced by $1 0 \mathrm { x }$ for the first step, as the two mini
+
+![](images/be5a2f2c3e52d82fda477343e585a6188e8dfe084d5dcd956461ed0044be4aff.jpg)  
+Figure 4: Streaming SVRG Variance at epoch 50
+
+batch terms cancel in Equation 2, resulting in just the mega-batch being used. The variance quickly rises thereafter. These results are similar to the non-streaming SVRG method, as we see that much greater variance reduction is possible for LeNet. Recall that the amortized cost of each step is three times that of SGD, so for the DenseNet model the amount of variance reduction is not compelling.
+
+# 7 CONVERGENCE RATE COMPARISONS
+
+Together with the direct measures of variance reduction in Section 3, we also directly compared the convergence rate of SGD, SVRG and the streaming method SCSG. The results are shown in Figure 5. An average of 10 runs is shown for each method, using the same momentum (0.9) and learning rate (0.1) parameters for each, with a 10-fold reduction in learning rate at epochs 150 and 225. A comparison was also performed on ImageNet with a single run of each method.
+
+The variance reduction seen in SVRG comes at the cost of the introduction of heavy correlation between consecutive steps. This is why the reduction in variance does not have the direct impact that increasing batch size or decreasing learning rate has on the convergence rate, and why convergence theory for VR methods requires careful proof techniques. It is for this reason that the amount of variance reduction in Figure 4 doesn’t necessarily manifest as a direct improvement in convergence rate in practice. On the LeNet problem we see that SVRG converges slightly faster than SGD, whereas on the larger problems including ResNet on ImageNet (Figure 5b) and DenseNet on CIFAR10 they are a little slower than SGD . This is consistent with the differences in the amount of variance reduction observed in the two cases in Figure 2, and our hypothesis that SVRG performs worse for larger models. The SCSG variant performs the worst in each comparison.
+
+![](images/404ed98b6ad9c9ac87ca39d30ba1a2065f250b20b075055b7e92f45224a86ae5.jpg)  
+Figure 5: Test error comparison with an average of 10 runs shown. Epochs rather than gradient evaluations are plotted on the $x$ axis. Best performing hyper-parameters are used.
+
+(b) Wide networks   
+Table 1: Variance and test error average when using SVRG and SGD between epochs 45-50 for a variety of ResNet architectures. Standard errors are shown using 9 runs for each architecture with different seeds. Planes is the number of activation planes after the first convolution.   
+
+<table><tr><td rowspan=1 colspan=1>Layers</td><td rowspan=1 colspan=1>Planes</td><td rowspan=1 colspan=1>Params.</td><td rowspan=1 colspan=1>Variance</td><td rowspan=1 colspan=1>Error @ 50 epochs</td><td rowspan=1 colspan=2>Final error   Final error (SGD)</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>0.3m</td><td rowspan=1 colspan=1>1.80 (±.01)</td><td rowspan=1 colspan=1>16.7% (±.2)</td><td rowspan=1 colspan=2>8.84% (±.03)    8.64%(±.02)</td></tr><tr><td rowspan=1 colspan=1>56</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>0.8m</td><td rowspan=1 colspan=1>1.83 (±.01)</td><td rowspan=1 colspan=1>15.0%(±.2)</td><td rowspan=1 colspan=2>7.22%(±.03)    7.06%(±.02)</td></tr><tr><td rowspan=1 colspan=1>92</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>1.4m</td><td rowspan=1 colspan=1>1.88(±.01)</td><td rowspan=1 colspan=1>14.8%(±.2)</td><td rowspan=1 colspan=2>6.84%(±.02)   6.65%(±.03)</td></tr><tr><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>2.0m</td><td rowspan=1 colspan=1>1.98 (±.01)</td><td rowspan=1 colspan=1>15.1%(±.2）</td><td rowspan=1 colspan=2>6.77%(±.02)   6.50%(±.02)</td></tr><tr><td rowspan=1 colspan=1>164</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>2.6m</td><td rowspan=1 colspan=1>2.13 (±.03)</td><td rowspan=1 colspan=1>15.4%（±.2)</td><td rowspan=1 colspan=2>6.84% (±.04)   6.30%(±.02)</td></tr><tr><td rowspan=1 colspan=1>200</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>3.2m</td><td rowspan=1 colspan=1>2.28 (±.03)</td><td rowspan=1 colspan=1>16.0% (±.2)</td><td rowspan=1 colspan=2>7.02% (±.05)    6.54% (±.03)</td></tr><tr><td rowspan=1 colspan=7>(a) Deep networks</td></tr><tr><td rowspan=1 colspan=1>Layers</td><td rowspan=1 colspan=1>Planes</td><td rowspan=1 colspan=1>Params.</td><td rowspan=1 colspan=1>Variance</td><td rowspan=1 colspan=1>Error @ 50 epochs</td><td rowspan=1 colspan=2>Final error   Final error (SGD)</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>0.3m</td><td rowspan=1 colspan=1>1.80 (±.01)</td><td rowspan=1 colspan=1>16.7% (±.2)</td><td rowspan=1 colspan=2>8.84% (±.03)    8.64% (±.02)</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>1.1m</td><td rowspan=1 colspan=1>1.83 (±.01)</td><td rowspan=1 colspan=1>13.8%(±.2)</td><td rowspan=1 colspan=1>6.74%(±.02)</td><td rowspan=1 colspan=1>6.46%(±.03)</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>48</td><td rowspan=1 colspan=1>2.4m</td><td rowspan=1 colspan=1>1.78 (±.01)</td><td rowspan=1 colspan=1>12.7%(±.2)</td><td rowspan=1 colspan=1>5.97%(±.02)</td><td rowspan=1 colspan=1>5.92%(±.02)</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>4.3m</td><td rowspan=1 colspan=1>1.75 (±.01)</td><td rowspan=1 colspan=1>12.5%(±.2）</td><td rowspan=1 colspan=1>5.69%(±.02)</td><td rowspan=1 colspan=1>5.65%(±.02)</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>6.8m</td><td rowspan=1 colspan=1>1.67 (±.02)</td><td rowspan=1 colspan=1>11.8%(±.2）)</td><td rowspan=1 colspan=1>5.46%(±.02)</td><td rowspan=1 colspan=1>5.45%(±.02)</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>9.7m</td><td rowspan=1 colspan=1>1.60 (±.02)</td><td rowspan=1 colspan=1>11.5%(±.2)</td><td rowspan=1 colspan=1>5.39%(±.02)</td><td rowspan=1 colspan=1>5.38%(±.01)</td></tr></table>
+
+# 8 GRADIENT VARIANCE
+
+A key difference between the theoretical rate for SGD and SVRG is the dependence on the variance of the gradient. SVRG’s convergence rate does not depend on the variance of the gradient, whereas SGD crucially does. SVRG should perform relatively better for very high gradient variance problems, assuming the Lipschitz smoothness is comparable.
+
+Surprisingly, we found that the gradient variance only increases modestly as depth increases for ResNet architectures. Scaling the depth of the network 10 fold (Table 1) only increases the variance $\approx 2 5 \%$ , and scaling the width actually leaves the variance roughly $10 \%$ smaller. These small changes give some indication why SVRG doesn’t perform better for the larger architectures. Table 1 also shows that the test error at 50 epochs is highly correlated with the variance. The deeper models with $1 0 0 +$ layers actually have worse test error at epoch 50 than the baseline 20 layer model. Their higher variance results in slower convergence when using a fixed step size. In contrast, increasing the model width while fixing the number of layers results in consistently lower gradient variance as well as lower test error at epoch 50. These results suggest that lower gradient variance is a contributing factor to the success of wider models such as the WRN (Zagoruyko & Komodakis, 2016). Notice also that there is a test error gap between SVRG and SGD for the fully trained deep models, whereas the wide models have no apparent gap.
+
+# CONCLUSION
+
+The negative results presented here are disheartening, however we don’t believe that they rule out the use of stochastic variance reduction on deep learning problems. Rather, they suggest avenues for further research. For instance, SVR can be applied adaptively; or on a meta level to learning rates; or scaling matrices; and can potentially be combined with methods like Adagrad (Duchi et al., 2011) and ADAM Kingma & Ba (2014) to yield hybrid methods.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, ´ Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, Oriol Vinyals, Pete Warden, Martin Watten- ´ berg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL https://www.tensorflow.org/.
+
+Zeyuan Allen-Zhu. Katyusha: The first direct acceleration of stochastic gradient methods. In Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2017, 2017.
+
+Zeyuan Allen-Zhu and Elad Hazan. Variance reduction for faster non-convex optimization. In Proceedings of The 33rd International Conference on Machine Learning, 2016.
+
+P. Balamurugan and Francis Bach. Stochastic variance reduction methods for saddle-point problems. Advances in Neural Information Processing Systems 29 (NIPS2016), 2016.
+
+Alberto Bietti and Julien Mairal. Stochastic optimization with variance reduction for infinite datasets with finite sum structure. In Advances in Neural Information Processing Systems 30 (NIPS 2017), 2017.
+
+Djork-Arne Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network learning by exponential linear units (elus). In International conference on learning representations 2016 (ICLR 2016). 2016.
+
+Aaron Defazio. A simple practical accelerated method for finite sums. Advances in Neural Information Processing Systems 29 (NIPS 2016), 2016.
+
+Aaron Defazio, Francis Bach, and Simon Lacoste-Julien. Saga: A fast incremental gradient method with support for non-strongly convex composite objectives. Advances in Neural Information Processing Systems 27 (NIPS 2014), 2014a.
+
+Aaron Defazio, Tiberio Caetano, and Justin Domke. Finito: A faster, permutable incremental gradient method for big data problems. The 31st International Conference on Machine Learning (ICML 2014), 2014b.
+
+John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. Journal of Machine Learning Research, 12(Jul):2121–2159, 2011.
+
+Roy Frostig, Rong Ge, Sham M. Kakade, and Aaron Sidford. Competing with the empirical risk minimizer in a single pass. In Proceedings of The 28th Conference on Learning Theory, 2015.
+
+Priya Goyal, Piotr DollA¡r, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, An- ˜ drew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. 06 2017.
+
+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.
+
+Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q. Weinberger. Densely connected convolutional networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the 32nd International Conference on Machine Learning, 2015.
+
+Rie Johnson and Tong Zhang. Accelerating stochastic gradient descent using predictive variance reduction. Advances in Neural Information Processing Systems 26 (NIPS2013), 2013.
+
+Rahul Kidambi, Praneeth Netrapalli, Prateek Jain, and Sham M. Kakade. On the insufficiency of existing momentum schemes for stochastic optimization. International Conference on Learning Representations (ICLR), 2018, Vancouver, Canada, 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Y. Lecun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 1998.
+
+Lihua Lei and Michael Jordan. Less than a Single Pass: Stochastically Controlled Stochastic Gradient. In Proceedings of the 20th International Conference on Artificial Intelligence and Statistics, 2017.
+
+Lihua Lei, Cheng Ju, Jianbo Chen, and Michael I Jordan. Non-convex finite-sum optimization via scsg methods. In Advances in Neural Information Processing Systems 30. 2017.
+
+Hongzhou Lin, Julien Mairal, and Zaid Harchaoui. A universal catalyst for first-order optimization. In Advances in Neural Information Processing Systems 28. 2015.
+
+Julien Mairal. Incremental majorization-minimization optimization with application to large-scale machine learning. Technical report, INRIA Grenoble Rhone-Alpes / LJK Laboratoire Jean Kuntz- ˆ mann, 2014.
+
+Sashank J. Reddi, Ahmed Hefny, Suvrit Sra, Barnabas P ´ ocz ´ os, and Alex Smola. Stochastic variance ´ reduction for nonconvex optimization. In Proceedings of the 33rd International Conference on International Conference on Machine Learning - Volume 48, ICML’16, 2016.
+
+Mark Schmidt, Nicolas Le Roux, and Francis Bach. Minimizing finite sums with the stochastic average gradient. F. Math. Program., 2017.
+
+Shai Shalev-Shwartz and Tong Zhang. Stochastic dual coordinate ascent methods for regularized loss minimization. Journal of Machine Learning Research, 14, 2013.
+
+Shai Shalev-Shwartz and Tong Zhang. Accelerated proximal stochastic dual coordinate ascent for regularized loss minimization. Proceedings of the 31st International Conference on Machine Learning, 2014.
+
+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, 2014.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.

parse/train/B1MIBs05F7/B1MIBs05F7_content_list.json

@@ -0,0 +1,1401 @@
+[
+    {
+        "type": "text",
+        "text": "ON THE INEFFECTIVENESS OF VARIANCE REDUCED OPTIMIZATION FOR DEEP LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The application of stochastic variance reduction to optimization has shown remarkable recent theoretical and practical success. The applicability of these techniques to the hard non-convex optimization problems encountered during training of modern deep neural networks is an open problem. We show that naive application of the SVRG technique and related approaches fail, and explore why. ",
+        "bbox": [
+            232,
+            270,
+            764,
+            340
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            368,
+            336,
+            385
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Stochastic variance reduction (SVR) consists of a collection of techniques for the minimization of finite-sum problems: ",
+        "bbox": [
+            176,
+            395,
+            823,
+            424
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/95629c2a2a07c51c777c65b5aae7681da9d1a50e88179e929a5c0f837f37ffc5.jpg",
+        "text": "$$\n\\begin{array} { r } { f ( w ) = \\frac { 1 } { n } \\sum _ { i = 1 } ^ { N } f _ { i } ( w ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            428,
+            576,
+            450
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "such as those encountered in empirical risk minimization, where each $f _ { i }$ is the loss on a single training data point. Principle techniques include SVRG (Johnson & Zhang, 2013), SAGA (Defazio et al., 2014a), and their variants. SVR methods use control variates to reduce the variance of the traditional stochastic gradient descent (SGD) estimate $f _ { i } ^ { \\prime } ( w )$ of the full gradient $f ^ { \\prime } ( w )$ . Control variates are a classical technique for reducing the variance of a stochastic quantity without introducing bias. Say we have some random variable $X$ . Although we could use $X$ as an estimate of $E [ X ] = { \\bar { X } }$ , we can often do better through the use of a control variate $Y$ . If $Y$ is a random variable correlated with $X$ (i.e. $\\mathrm { C o v } [ X , Y ] > 0 $ ), then we can estimate $\\bar { X }$ with the quantity ",
+        "bbox": [
+            174,
+            458,
+            825,
+            570
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/65050e58905b77d2b458d613689543c46a3f63bf62dc016af204273c12a5fa8f.jpg",
+        "text": "$$\nZ = X - Y + E [ Y ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            426,
+            582,
+            571,
+            599
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This estimate is unbiased since $- Y$ cancels with $E [ Y ]$ when taking expectations, leaving $E [ Z ] =$ $E [ X ]$ . As long as $V a r [ Y ] \\leq 2  { \\mathrm { C o v } } [ X , Y ]$ , the variance of $Z$ is lower than that of $X$ . ",
+        "bbox": [
+            174,
+            609,
+            821,
+            638
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Remarkably, these methods are able to achieve linear convergence rates for smooth strongly-convex optimization problems, a significant improvement on the sub-linear rate of SGD. SVR methods are part of a larger class of methods that explicitly exploit finite-sum structures, either by dual (SDCA, Shalev-Shwartz & Zhang, 2013; MISO, Mairal, 2014; Finito, Defazio et al., 2014b) or primal (SAG, Schmidt et al., 2017) approaches. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            715
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent work has seen the fusion of acceleration with variance reduction (Shalev-Shwartz & Zhang (2014); Lin et al. (2015); Defazio (2016); Allen-Zhu (2017)), and the extension of SVR approaches to general non-convex (Allen-Zhu & Hazan, 2016; Reddi et al., 2016) as well as saddle point problems (Balamurugan & Bach, 2016). ",
+        "bbox": [
+            173,
+            722,
+            825,
+            779
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work we study the behavior of variance reduction methods on a prototypical non-convex problem in machine learning: A deep convolutional neural network designed for image classification. We discuss in Section 2 how standard training and modeling techniques significantly complicate the application of variance reduction methods in practice, and how to overcome some of these issues. In Sections 3 & 5 we study empirically the amount of variance reduction seen in practice on modern CNN architectures, and we quantify the properties of the network that affect the amount of variance reduction. In Sections 6 & 7 we show that streaming variants of SVRG do not improve over regular SVRG despite their theoretical ability to handle data augmentation. In Section 8 we study properties of DNN problems that actually give stochastic gradient descent an advantage over variance reduction techniques. ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "STANDARD SVR APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            408,
+            118
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The SVRG method is the simplest of the variance reduction approaches to apply for large-scale problems, so we will focus our initial discussion on it. In SVRG, training epochs are interlaced with snapshot points where a full gradient evaluation is performed. The iterate at the snapshot point $\\tilde { w }$ is stored, along with the full gradient $f ^ { \\prime } ( \\tilde { w } )$ . Snapshots can occur at any interval, although once per epoch is the most common frequency used in practice. The SGD step $w _ { k + 1 } = w _ { k } - \\gamma f _ { i } ^ { \\prime } ( w _ { k } )$ , using the randomly sampled data-point loss $f _ { i }$ with step size $\\gamma$ , is augmented with the snapshot gradient using the control variate technique to form the SVRG step: ",
+        "bbox": [
+            173,
+            126,
+            825,
+            224
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b229b16d122904c799bc7ef9a84872a67ef5b782a452aa127e8ec2d9fb7288cc.jpg",
+        "text": "$$\nw _ { k + 1 } = w _ { k } - \\gamma \\left[ f _ { i } ^ { \\prime } ( w _ { k } ) - f _ { i } ^ { \\prime } ( \\tilde { w } ) + f ^ { \\prime } ( \\tilde { w } ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            231,
+            647,
+            250
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The single-data point gradient $f _ { i } ^ { \\prime } ( \\tilde { w } )$ may be stored during the snapshot pass and retrieved, or recomputed when needed. The preference for recomputation or storage depends a lot on the computer architecture and its bottlenecks, although recomputation is typically the most practical approach. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            306
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Notice that following the control variate approach, the expected step, conditioning on $w _ { k }$ , is just a gradient step. So like SGD, it is an unbiased step. Unbiasedness is not necessary for the fast rates obtainable by SVR methods, both SAG (Schmidt et al., 2017) and Point-SAGA (Defazio, 2016) use biased steps, however biased methods are harder to analyze. Note also that successive step directions are highly correlated, as the $f ^ { \\prime } ( \\tilde { w } )$ term appears in every consecutive step between snapshots. This kind of step correlation is also seen in momentum methods, and is considered a contributing factor to their effectiveness (Kidambi et al., 2018). ",
+        "bbox": [
+            173,
+            313,
+            825,
+            410
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 COMPLICATIONS IN PRACTICE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            425,
+            457,
+            440
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Modern approaches to training deep neural networks deviate significantly from the assumptions that SVR methods are traditionally analyzed under. In this section we discuss the major ways in which practice deviates from theory and how to mitigate any complications that arise. ",
+        "bbox": [
+            174,
+            449,
+            825,
+            491
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "DATA AUGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            511,
+            331,
+            523
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In order to achieve state-of-the-art results in most domains, data augmentation is essential. The standard approach is to form a class of transform functions $\\tau$ ; for an image domain typical transforms include cropping, rotation, flipping and compositions thereof. Before the gradient calculation for a data-point $x _ { i }$ , a transform $T _ { i }$ is sampled and the gradient is evaluated on its image $T _ { i } ( x _ { i } )$ . ",
+        "bbox": [
+            174,
+            530,
+            485,
+            655
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "When applying standard SVRG using gradient recomputation, the use of random transforms can destroy the prospects of any variance reduction if different transforms are used for a datapoint during the snapshot pass compared to the following steps. Using a different transform is unfortunately the most natural implementation ",
+        "bbox": [
+            174,
+            661,
+            483,
+            758
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/039b79a0d535a263c8eac581f288d7980e7962dbafcf0015cee9947e419b83ee.jpg",
+        "image_caption": [
+            "Figure 1: Variance within epoch two during LeNet training on CIFAR10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            544,
+            812,
+            700
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "when using standard libraries (PyTorch1; TensorFlow, Abadi et al. (2015)), as the transform is applied automatically as part of the data-pipeline. We propose the use of transform locking, where the transform used during the snapshot pass is cached and reused during the following epoch/s. ",
+        "bbox": [
+            176,
+            758,
+            825,
+            800
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This performance difference is illustrated in Figure 1, where the variance of the SVRG step is compared with and without transform locking during a single epoch during training of a LeNet model. Data augmentation consisted of random horizontal flips and random cropping to $3 2 \\mathbf { x } 3 2$ , after padding by 4 pixels on each side (following standard practice). ",
+        "bbox": [
+            174,
+            806,
+            825,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For SVRG with transform locking, the variance of the step is initially zero at the very beginning of the epoch, increasing over the course of the epoch. This is the behavior expected of SVRG on finite sum problems. In contrast, without transform locking the variance is non-zero at the beginning of the epoch, and uniformly worse. ",
+        "bbox": [
+            176,
+            869,
+            823,
+            898
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The handling of data augmentation in finite-sum methods has been previously considered for the MISO method (Bietti & Mairal, 2017), which is one of the family of gradient table methods (as with the storage variant of SVRG). The stored gradients are updated with an exponential moving average instead of overwriting, which averages over multiple past transformed-data-point gradients. As we show in Section 5, stored gradients can quickly become too stale to provide useful information when training large models. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            222
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "BATCH NORMALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            237,
+            346,
+            251
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Batch normalization (Ioffe & Szegedy, 2015) is another technique that breaks the finite-sum structure assumption. In batch normalization, mean and variance statistics are calculated within a minibatch, for the activations of each layer (typically before application of a nonlinearity). These statistics are used to normalize the activations. The finite sum structure no longer applies since the loss on a datapoint $i$ depends on the statistics of the mini-batch it is sampled in. ",
+        "bbox": [
+            174,
+            257,
+            823,
+            327
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The interaction of BN with SVRG depends on if storage or recomputation of gradients is used. When recomputation is used naively, catastrophic divergence occurs in standard frameworks. The problem is a subtle interaction with the internal computation of running means and variances, for use at test time. ",
+        "bbox": [
+            174,
+            333,
+            823,
+            390
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In order to apply batch normalization at test time, where data may not be mini-batched or may not have the same distribution as training data, it is necessary to store mean and variance information at training time for later use. The standard approach is to keep track of a exponential moving average of the mean and variances computed at each training step. For instance, PyTorch by default will update the moving average $m _ { E M A }$ using the mini-batch mean $m$ as: ",
+        "bbox": [
+            174,
+            397,
+            825,
+            467
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/874d6d3aae274374c432411ba775e007c4d6af1b7ef9a10fa9b2137f03bb9758.jpg",
+        "text": "$$\nm _ { E M A } = \\frac { 9 } { 1 0 } m _ { E M A } + \\frac { 1 } { 1 0 } m .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            476,
+            599,
+            507
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "During test time, the network is switched to evaluation mode using model.eval(), and the stored running mean and variances are then used instead of the internal mini-batch statistics for normalization. The complication with SVRG is that during training the gradient evaluations occur both at the current iterate $x _ { k }$ and the snapshot iterate $\\tilde { x }$ . If the network is in train mode for both, the EMA will average over activation statistics between two different points, resulting in poor results and divergence. ",
+        "bbox": [
+            174,
+            522,
+            825,
+            606
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Switching the network to evaluation mode mid-step is the obvious solution, however computing the gradient using the two different sets of normalizations results in additional introduced variance. We recommend a BN reset approach, where the normalization statistics are temporarily stored before the $\\tilde { w }$ gradient evaluation, and the stored statistics are used to undo the updated statistics by overwriting afterwards. This avoids having to modify the batch normalization library code. It is important to use train mode during the snapshot pass as well, so that the mini-batch statistics match between the two evaluations. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            710
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "DROPOUT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            724,
+            245,
+            738
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Dropout (Srivastava et al., 2014) is another popular technique that affects the finite-sum assumption. When dropout is in use, a random fraction, usually $50 \\%$ , of the activations will be zero at each step. This is extremely problematic when used in conjunction with variance reduction, since the sparsity pattern will be different for the snapshot evaluation of a datapoint compared to its evaluation during the epoch, resulting in much lower correlation and hence lower variance reduction. ",
+        "bbox": [
+            174,
+            746,
+            823,
+            815
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The same dropout pattern can be used at both points as with the transform locking approach proposed above. The seed used for each data-point’s sparsity pattern should be stored during the snapshot pass, and reused during the following epoch when that data-point is encountered. Storing the sparsity patterns directly is not practical as it will be many times larger than memory even for simple models. ",
+        "bbox": [
+            174,
+            821,
+            825,
+            878
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Residual connection architectures benefit very little from dropout when batch-norm is used (He et al., 2016; Ioffe & Szegedy, 2015), and because of this we don’t use dropout in the experiments detailed in this work, following standard practice. ",
+        "bbox": [
+            176,
+            885,
+            823,
+            928
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "ITERATE AVERAGING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            323,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Although it is common practice to use the last iterate of an epoch as the snapshot point for the next epoch, standard SVRG theory requires computing the snapshot at either an average iterate or a randomly chosen iterate from the epoch instead. Averaging is also needed for SGD when applied to non-convex problems. We tested both SVRG and SGD using averaging of $100 \\%$ , $50 \\%$ or $10 \\%$ of the tail of each epoch as the starting point of the next epoch. Using a $10 \\%$ tail average did result in faster initial convergence for both methods before the first step size reduction on the CIFAR10 test problem (detailed in the next section). However, this did not lead to faster convergence after the first step size reduction, and final test error was consistently worse than without averaging. For this reason we did not use iterate averaging in the experiments presented in this work. ",
+        "bbox": [
+            174,
+            123,
+            825,
+            248
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 MEASURING VARIANCE REDUCTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            263,
+            506,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To illustrate the degree of variance reduction achieved by SVRG on practical problems, we directly computed the variance of the SVRG gradient estimate, comparing it to the variance of the stochastic gradient used by SGD. To minimize noise the variance was estimated using the full dataset. The transform locking and batch norm reset techniques described above were used in order to get the most favorable performance out of SVRG. ",
+        "bbox": [
+            174,
+            287,
+            823,
+            357
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Ratios below one indicate that variance reduction is occurring, whereas ratios around two indicate that the control variate is uncorrelated with the stochastic gradient, leading to an increase in variance. For SVRG to be effective we need a ratio below $1 / 3$ to offset the additional computational costs of the method. We plot the variance ratio at multiple points within each epoch as it changes significantly during each epoch. An initial step size of 0.1 was used, with 10-fold decreases at 150 and 220 epochs. A batch size of 128 with momentum 0.9 was used for all methods. ",
+        "bbox": [
+            174,
+            364,
+            825,
+            448
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To highlight differences introduced by model complexity, we compared four models: ",
+        "bbox": [
+            176,
+            455,
+            728,
+            469
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. The classical LeNet-5 model (Lecun et al., 1998), modified to use batch-norm and ReLUs, with approximately 62 thousand parameters2.   \n2. A ResNet-18 model (He et al., 2016), scaled down to match the model size of the LeNet model by halving the number of feature planes at each layer. It has approximately 69 thousand parameters.   \n3. A ResNet-110 model with $1 . 7 \\mathrm { m }$ parameters, as used by He et al. (2016).   \n4. A wide DenseNet model (Huang et al., 2017) with growth rate 36 and depth 40. It has approximately 1.5 million parameters and achieves below $5 \\%$ test error. ",
+        "bbox": [
+            210,
+            481,
+            825,
+            611
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 shows how this variance ratio depends dramatically on the model used. For the LeNet model, the SVRG step has consistently lower variance, from $4 \\mathbf { x }$ to $2 \\mathbf { x }$ depending on the position within the epoch, during the initial phase of convergence. ",
+        "bbox": [
+            176,
+            622,
+            825,
+            665
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In contrast, the results for the DenseNet-40-36 model as well as the ResNet-110 model show an increase in variance, for the majority of each epoch, up until the first step size reduction at epoch 150. Indeed, even at only $2 \\%$ progress through each epoch, the variance reduction is only a factor of 2, so computing the snapshot pass more often than once an epoch can not help during the initial phase of optimization. ",
+        "bbox": [
+            174,
+            671,
+            825,
+            741
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The small ResNet model sits between these two extremes, showing some variance reduction midepoch at the early stages of optimization. Compared to the LeNet model of similar size, the modern architecture with its greater ability to fit the data also benefits less from the use of SVRG. ",
+        "bbox": [
+            174,
+            748,
+            825,
+            790
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 SNAPSHOT INTERVALS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            806,
+            393,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The number of stochastic steps between snapshots has a significant effect on the practical performance of SVRG. In the classical convex theory the interval should be proportional to the condition number (Johnson & Zhang, 2013), but in practice an interval of one epoch is commonly used, and that is what we used in the experiment above. A careful examination of our results from Figure 2 ",
+        "bbox": [
+            174,
+            830,
+            825,
+            886
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/6c43addcbbbe54847f10581970302758718e19526d1c74a18b82ffe1ebbc373b.jpg",
+        "image_caption": [
+            "Figure 2: The SVRG to SGD gradient variance ratio during a run of SVRG. The shaded region indicates a variance increase, where the SVRG variance is worse than the SGD baseline. Dotted lines indicate when the step size was reduced. The variance ratio is shown at different points within each epoch, so that the $2 \\%$ dots (for instance) indicate the variance at 1,000 data-points into the 50,000 datapoints consisting of the epoch. Multiple percentages within the same run are shown at equally spaced epochs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            116,
+            810,
+            454
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "SVRG fails to show a variance reduction for the majority of each epoch when applied to modern high-capacity networks, whereas some variance reduction is seem for smaller networks. ",
+        "bbox": [
+            171,
+            545,
+            823,
+            571
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "show that no adjustment to the snapshot interval can salvage the method. The SVRG variance can be kept reasonable (i.e. below the SGD variance) by reducing the duration between snapshots, however for the ResNet-110 and DenseNet models, even at $11 \\%$ into an epoch, the SVRG step variance is already larger than that of SGD, at least during the crucial 10-150 epochs. If we were to perform snapshots at this frequency the wall-clock cost of the SVRG method would go up by an order of magnitude compared to SGD, while still under-performing on a per-epoch basis. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            686
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Similarly, we can consider performing snapshots at less frequent intervals. Our plots show that the variance of the SVRG gradient estimate will be approximately $2 \\mathbf { x }$ the variance of the SGD estimate on the harder two problems in this case (during epochs 10-150), which certainly will not result in faster convergence. This is because the correction factor in Equation 1 becomes so out-of-date that it becomes effectively uncorrelated with the stochastic gradient, and since it’s magnitude is comparable (the gradient norm decays relatively slowly during optimization for these networks) adding it to the stochastic gradient results in a doubling of the variance. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            791
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 VARIANCE REDUCTION AND OPTIMIZATION SPEED ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            814,
+            563,
+            827
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For sufficiently well-behaved objective functions (such as smooth & strongly convex), we can expect that an increase of the learning rate results in a increase of the converge rate, up until the learning rate approaches a limit defined by the curvature $( \\approx 1 / L$ for $\\mathrm { L }$ Lipschitz-smooth functions). This holds also in the stochastic case for small learning rates, however there is an additional ceiling that occurs as you increase the learning rate, where the variance of the gradient estimate begins to slow convergence. Which ceiling comes into effect first determines if a possible variance reduction (such as from SVRG) can allow for larger learning rates and thus faster convergence. Although clearly a simplified view of the non-differentiable non-convex optimization problem we are considering, it still offers some insight. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/ac068d351d4a05aef0bb4416f00340b1da13080b46f98c0d1e7947cfd0fac601.jpg",
+        "image_caption": [
+            "Figure 3: Distance moved from the snapshot point, and curvature relative to the snapshot point, at epoch 50. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            99,
+            810,
+            253
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            314,
+            823,
+            357
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Empirically deep residual networks are known to be constrained by the curvature for a few initial epochs, and afterwards are constrained by the variance. For example, Goyal et al. (2017) show that decreasing the variance by increasing the batch-size allows them to proportionally increase the learning rate for variance reduction factors up to 30 fold. This is strong evidence that a SVR technique that results in significant variance reduction can potentially improve convergence in practice. ",
+        "bbox": [
+            174,
+            363,
+            825,
+            434
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 WHY VARIANCE REDUCTION FAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            455,
+            496,
+            470
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 clearly illustrates that for the DenseNet model, SVRG gives no actual variance reduction for the majority of the optimization run. This also holds for larger ResNet models (plot omitted). The variance of the SVRG estimator is directly dependent on how similar the gradient is between the snapshot point $\\tilde { x }$ and the current iterate $x _ { k }$ . Two phenomena may explain the differences seen here. If the $w _ { k }$ iterate moves too quickly through the optimization landscape, the snapshot point will be too out-of-date to provide meaningful variance reduction. Alternatively, the gradient may just change more rapidly in the larger model. ",
+        "bbox": [
+            173,
+            478,
+            825,
+            577
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 sheds further light on this. The left plot shows how rapidly the current iterate moves within the same epoch for LeNet and DenseNet models when training using SVRG. The distance moved from the snapshot point increases significantly faster for the DenseNet model compared to the LeNet model. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            638
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In contrast the right plot shows the curvature change during an epoch, which we estimated as: ",
+        "bbox": [
+            171,
+            646,
+            785,
+            661
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9ffddce46a08a4b239070044ce753929f6fee7e3d30b76c5402fd839c39e6412.jpg",
+        "text": "$$\n\\begin{array} { r } { \\Big \\| \\frac { 1 } { | S _ { i } | } \\sum _ { j \\in S _ { i } } \\left[ f _ { j } ^ { \\prime } ( w _ { k } ) - f _ { j } ^ { \\prime } ( \\tilde { w } ) \\right] \\Big \\| / \\| w _ { k } - \\tilde { w } \\| , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            662,
+            648,
+            689
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $S _ { i }$ is a sampled mini-batch. This can be seen as an empirical measure of the Lipschitz smoothness constant. Surprisingly, the measured curvature is very similar for the two models, which supports the idea that iterate distance is the dominating factor in the lack of variance reduction. The curvature is highest at the beginning of an epoch because of the lack of smoothness of the objective (the Lipschitz smoothness is potentially unbounded for non-smooth functions). ",
+        "bbox": [
+            174,
+            695,
+            825,
+            766
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Several papers have show encouraging results when using SVRG variants on small MNIST training problems (Johnson & Zhang, 2013; Lei et al., 2017). Our failure to show any improvement when using SVRG on larger problems should not be seen as a refutation of their results. Instead, we believe it shows a fundamental problem with MNIST as a baseline for optimization comparisons. Particularly with small neural network architectures, it is not representative of harder deep learning training problems. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            856
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 SMOOTHNESS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            864,
+            312,
+            878
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Since known theoretical results for SVRG apply only to smooth objectives, we also computed the variance when using the ELU activation function (Clevert et al., 2016), a popular smooth activation that can be used as a drop-in replacement for ReLU. We did see a small improvement in the degree ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "of variance reduction when using the ELU. There was still no significant variance reduction on the DenseNet model. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 STREAMING SVRG VARIANTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            145,
+            460,
+            162
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Section 3, we saw that the amount of variance reduction quickly diminished as the optimization procedure moved away from the snapshot point. One potential fix is to perform snapshots at finer intervals. To avoid incurring the cost of a full gradient evaluation at each snapshot, the class of streaming SVRG (Frostig et al., 2015; Lei et al., 2017) methods instead use a mega-batch to compute the snapshot point. A mega-batch is typically 10-32 times larger than a regular mini-batch. To be precise, let the mini-batch size be $b$ be and the mega-batch size be $B$ . Streaming SVRG alternates between computing a snapshot mega-batch gradient $\\tilde { g }$ at $\\tilde { w } = w _ { k }$ , and taking a sequence of SVRG inner loop steps where a mini-batch $S _ { k }$ is sampled, then a step is taken: ",
+        "bbox": [
+            173,
+            169,
+            825,
+            281
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2a902c04bde5d6ac821bd5b67031c203cf6e92c585f10dacfc9dd5cc96db114a.jpg",
+        "text": "$$\nw _ { k + 1 } = w _ { k } - \\gamma \\left[ \\frac { 1 } { n } \\sum _ { i \\in S _ { k } } \\left( f _ { i } ^ { \\prime } ( w _ { k } ) - f _ { i } ^ { \\prime } ( \\tilde { w } ) \\right) + \\tilde { g } \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            286,
+            665,
+            330
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Although the theory suggests taking a random number of these steps, often a fixed $m$ steps is used in practice. ",
+        "bbox": [
+            174,
+            337,
+            825,
+            364
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this formulation the data-points from the mega-batch and subsequent $m$ steps are independent. Some further variance reduction is potentially possible by sampling the mini-batches for the inner step from the mega-batch, but at the cost of some bias. This approach has been explored as the Stochastically Controlled Stochastic Gradient (SCSG) method (Lei & Jordan, 2017). ",
+        "bbox": [
+            173,
+            371,
+            825,
+            428
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To investigate the effectiveness of streaming SVRG methods we produced variance-overtime plots. We look at the variance of each individual step after the computation of a megabatch, where our mega-batches were taken as $1 0 \\mathrm { x }$ larger than our mini-batch size of $1 2 8 ~ \\mathrm { C I } -$ FAR10 instances, and 10 inner steps were taken per snapshot. The data augmentation and batch norm reset techniques from Section 2 were used to get the lowest variance possible. The variance is estimated using the full dataset at each point. ",
+        "bbox": [
+            174,
+            435,
+            485,
+            601
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows the results at the beginning of the 50th epoch. In both cases the variance is reduced by $1 0 \\mathrm { x }$ for the first step, as the two mini",
+        "bbox": [
+            173,
+            608,
+            485,
+            650
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/be5a2f2c3e52d82fda477343e585a6188e8dfe084d5dcd956461ed0044be4aff.jpg",
+        "image_caption": [
+            "Figure 4: Streaming SVRG Variance at epoch 50 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            503,
+            452,
+            816,
+            609
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "batch terms cancel in Equation 2, resulting in just the mega-batch being used. The variance quickly rises thereafter. These results are similar to the non-streaming SVRG method, as we see that much greater variance reduction is possible for LeNet. Recall that the amortized cost of each step is three times that of SGD, so for the DenseNet model the amount of variance reduction is not compelling. ",
+        "bbox": [
+            173,
+            650,
+            825,
+            705
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7 CONVERGENCE RATE COMPARISONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            727,
+            509,
+            742
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Together with the direct measures of variance reduction in Section 3, we also directly compared the convergence rate of SGD, SVRG and the streaming method SCSG. The results are shown in Figure 5. An average of 10 runs is shown for each method, using the same momentum (0.9) and learning rate (0.1) parameters for each, with a 10-fold reduction in learning rate at epochs 150 and 225. A comparison was also performed on ImageNet with a single run of each method. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            819
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The variance reduction seen in SVRG comes at the cost of the introduction of heavy correlation between consecutive steps. This is why the reduction in variance does not have the direct impact that increasing batch size or decreasing learning rate has on the convergence rate, and why convergence theory for VR methods requires careful proof techniques. It is for this reason that the amount of variance reduction in Figure 4 doesn’t necessarily manifest as a direct improvement in convergence rate in practice. On the LeNet problem we see that SVRG converges slightly faster than SGD, whereas on the larger problems including ResNet on ImageNet (Figure 5b) and DenseNet on CIFAR10 they are a little slower than SGD . This is consistent with the differences in the amount of variance reduction observed in the two cases in Figure 2, and our hypothesis that SVRG performs worse for larger models. The SCSG variant performs the worst in each comparison. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/404ed98b6ad9c9ac87ca39d30ba1a2065f250b20b075055b7e92f45224a86ae5.jpg",
+        "image_caption": [
+            "Figure 5: Test error comparison with an average of 10 runs shown. Epochs rather than gradient evaluations are plotted on the $x$ axis. Best performing hyper-parameters are used. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            112,
+            815,
+            284
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/9634662908d1186e5d09603e0deb29f57f362d0cdaf9091fa30fb2cd4e9b6ea1.jpg",
+        "table_caption": [
+            "(b) Wide networks ",
+            "Table 1: Variance and test error average when using SVRG and SGD between epochs 45-50 for a variety of ResNet architectures. Standard errors are shown using 9 runs for each architecture with different seeds. Planes is the number of activation planes after the first convolution. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Layers</td><td rowspan=1 colspan=1>Planes</td><td rowspan=1 colspan=1>Params.</td><td rowspan=1 colspan=1>Variance</td><td rowspan=1 colspan=1>Error @ 50 epochs</td><td rowspan=1 colspan=2>Final error   Final error (SGD)</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>0.3m</td><td rowspan=1 colspan=1>1.80 (±.01)</td><td rowspan=1 colspan=1>16.7% (±.2)</td><td rowspan=1 colspan=2>8.84% (±.03)    8.64%(±.02)</td></tr><tr><td rowspan=1 colspan=1>56</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>0.8m</td><td rowspan=1 colspan=1>1.83 (±.01)</td><td rowspan=1 colspan=1>15.0%(±.2)</td><td rowspan=1 colspan=2>7.22%(±.03)    7.06%(±.02)</td></tr><tr><td rowspan=1 colspan=1>92</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>1.4m</td><td rowspan=1 colspan=1>1.88(±.01)</td><td rowspan=1 colspan=1>14.8%(±.2)</td><td rowspan=1 colspan=2>6.84%(±.02)   6.65%(±.03)</td></tr><tr><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>2.0m</td><td rowspan=1 colspan=1>1.98 (±.01)</td><td rowspan=1 colspan=1>15.1%(±.2）</td><td rowspan=1 colspan=2>6.77%(±.02)   6.50%(±.02)</td></tr><tr><td rowspan=1 colspan=1>164</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>2.6m</td><td rowspan=1 colspan=1>2.13 (±.03)</td><td rowspan=1 colspan=1>15.4%（±.2)</td><td rowspan=1 colspan=2>6.84% (±.04)   6.30%(±.02)</td></tr><tr><td rowspan=1 colspan=1>200</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>3.2m</td><td rowspan=1 colspan=1>2.28 (±.03)</td><td rowspan=1 colspan=1>16.0% (±.2)</td><td rowspan=1 colspan=2>7.02% (±.05)    6.54% (±.03)</td></tr><tr><td rowspan=1 colspan=7>(a) Deep networks</td></tr><tr><td rowspan=1 colspan=1>Layers</td><td rowspan=1 colspan=1>Planes</td><td rowspan=1 colspan=1>Params.</td><td rowspan=1 colspan=1>Variance</td><td rowspan=1 colspan=1>Error @ 50 epochs</td><td rowspan=1 colspan=2>Final error   Final error (SGD)</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>0.3m</td><td rowspan=1 colspan=1>1.80 (±.01)</td><td rowspan=1 colspan=1>16.7% (±.2)</td><td rowspan=1 colspan=2>8.84% (±.03)    8.64% (±.02)</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>32</td><td rowspan=1 colspan=1>1.1m</td><td rowspan=1 colspan=1>1.83 (±.01)</td><td rowspan=1 colspan=1>13.8%(±.2)</td><td rowspan=1 colspan=1>6.74%(±.02)</td><td rowspan=1 colspan=1>6.46%(±.03)</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>48</td><td rowspan=1 colspan=1>2.4m</td><td rowspan=1 colspan=1>1.78 (±.01)</td><td rowspan=1 colspan=1>12.7%(±.2)</td><td rowspan=1 colspan=1>5.97%(±.02)</td><td rowspan=1 colspan=1>5.92%(±.02)</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>4.3m</td><td rowspan=1 colspan=1>1.75 (±.01)</td><td rowspan=1 colspan=1>12.5%(±.2）</td><td rowspan=1 colspan=1>5.69%(±.02)</td><td rowspan=1 colspan=1>5.65%(±.02)</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>6.8m</td><td rowspan=1 colspan=1>1.67 (±.02)</td><td rowspan=1 colspan=1>11.8%(±.2）)</td><td rowspan=1 colspan=1>5.46%(±.02)</td><td rowspan=1 colspan=1>5.45%(±.02)</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>9.7m</td><td rowspan=1 colspan=1>1.60 (±.02)</td><td rowspan=1 colspan=1>11.5%(±.2)</td><td rowspan=1 colspan=1>5.39%(±.02)</td><td rowspan=1 colspan=1>5.38%(±.01)</td></tr></table>",
+        "bbox": [
+            176,
+            335,
+            818,
+            570
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            657,
+            825,
+            700
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "8 GRADIENT VARIANCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            710,
+            388,
+            727
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A key difference between the theoretical rate for SGD and SVRG is the dependence on the variance of the gradient. SVRG’s convergence rate does not depend on the variance of the gradient, whereas SGD crucially does. SVRG should perform relatively better for very high gradient variance problems, assuming the Lipschitz smoothness is comparable. ",
+        "bbox": [
+            176,
+            734,
+            823,
+            791
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Surprisingly, we found that the gradient variance only increases modestly as depth increases for ResNet architectures. Scaling the depth of the network 10 fold (Table 1) only increases the variance $\\approx 2 5 \\%$ , and scaling the width actually leaves the variance roughly $10 \\%$ smaller. These small changes give some indication why SVRG doesn’t perform better for the larger architectures. Table 1 also shows that the test error at 50 epochs is highly correlated with the variance. The deeper models with $1 0 0 +$ layers actually have worse test error at epoch 50 than the baseline 20 layer model. Their higher variance results in slower convergence when using a fixed step size. In contrast, increasing the model width while fixing the number of layers results in consistently lower gradient variance as well as lower test error at epoch 50. These results suggest that lower gradient variance is a contributing factor to the success of wider models such as the WRN (Zagoruyko & Komodakis, 2016). Notice also that there is a test error gap between SVRG and SGD for the fully trained deep models, whereas the wide models have no apparent gap. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            157,
+            289,
+            172
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The negative results presented here are disheartening, however we don’t believe that they rule out the use of stochastic variance reduction on deep learning problems. Rather, they suggest avenues for further research. For instance, SVR can be applied adaptively; or on a meta level to learning rates; or scaling matrices; and can potentially be combined with methods like Adagrad (Duchi et al., 2011) and ADAM Kingma & Ba (2014) to yield hybrid methods. ",
+        "bbox": [
+            174,
+            178,
+            825,
+            247
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            268,
+            285,
+            284
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, ´ Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, Oriol Vinyals, Pete Warden, Martin Watten- ´ berg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL https://www.tensorflow.org/. ",
+        "bbox": [
+            176,
+            292,
+            825,
+            405
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zeyuan Allen-Zhu. Katyusha: The first direct acceleration of stochastic gradient methods. In Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2017, 2017. ",
+        "bbox": [
+            176,
+            416,
+            821,
+            458
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zeyuan Allen-Zhu and Elad Hazan. Variance reduction for faster non-convex optimization. In Proceedings of The 33rd International Conference on Machine Learning, 2016. ",
+        "bbox": [
+            173,
+            469,
+            821,
+            497
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "P. Balamurugan and Francis Bach. Stochastic variance reduction methods for saddle-point problems. Advances in Neural Information Processing Systems 29 (NIPS2016), 2016. ",
+        "bbox": [
+            174,
+            508,
+            820,
+            537
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alberto Bietti and Julien Mairal. Stochastic optimization with variance reduction for infinite datasets with finite sum structure. In Advances in Neural Information Processing Systems 30 (NIPS 2017), 2017. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            590
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Djork-Arne Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network learning by exponential linear units (elus). In International conference on learning representations 2016 (ICLR 2016). 2016. ",
+        "bbox": [
+            174,
+            602,
+            821,
+            645
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aaron Defazio. A simple practical accelerated method for finite sums. Advances in Neural Information Processing Systems 29 (NIPS 2016), 2016. ",
+        "bbox": [
+            169,
+            655,
+            823,
+            684
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aaron Defazio, Francis Bach, and Simon Lacoste-Julien. Saga: A fast incremental gradient method with support for non-strongly convex composite objectives. Advances in Neural Information Processing Systems 27 (NIPS 2014), 2014a. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            738
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aaron Defazio, Tiberio Caetano, and Justin Domke. Finito: A faster, permutable incremental gradient method for big data problems. The 31st International Conference on Machine Learning (ICML 2014), 2014b. ",
+        "bbox": [
+            173,
+            748,
+            825,
+            791
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. Journal of Machine Learning Research, 12(Jul):2121–2159, 2011. ",
+        "bbox": [
+            169,
+            801,
+            823,
+            830
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Roy Frostig, Rong Ge, Sham M. Kakade, and Aaron Sidford. Competing with the empirical risk minimizer in a single pass. In Proceedings of The 28th Conference on Learning Theory, 2015. ",
+        "bbox": [
+            171,
+            842,
+            821,
+            871
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Piotr DollA¡r, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, An- ˜ drew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. 06 2017. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "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,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q. Weinberger. Densely connected convolutional networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017. ",
+        "bbox": [
+            174,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the 32nd International Conference on Machine Learning, 2015. ",
+        "bbox": [
+            173,
+            207,
+            825,
+            250
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rie Johnson and Tong Zhang. Accelerating stochastic gradient descent using predictive variance reduction. Advances in Neural Information Processing Systems 26 (NIPS2013), 2013. ",
+        "bbox": [
+            173,
+            257,
+            821,
+            287
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rahul Kidambi, Praneeth Netrapalli, Prateek Jain, and Sham M. Kakade. On the insufficiency of existing momentum schemes for stochastic optimization. International Conference on Learning Representations (ICLR), 2018, Vancouver, Canada, 2018. ",
+        "bbox": [
+            173,
+            295,
+            826,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            174,
+            347,
+            823,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Y. Lecun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 1998. ",
+        "bbox": [
+            173,
+            385,
+            823,
+            414
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lihua Lei and Michael Jordan. Less than a Single Pass: Stochastically Controlled Stochastic Gradient. In Proceedings of the 20th International Conference on Artificial Intelligence and Statistics, 2017. ",
+        "bbox": [
+            173,
+            422,
+            825,
+            465
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lihua Lei, Cheng Ju, Jianbo Chen, and Michael I Jordan. Non-convex finite-sum optimization via scsg methods. In Advances in Neural Information Processing Systems 30. 2017. ",
+        "bbox": [
+            173,
+            473,
+            820,
+            503
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hongzhou Lin, Julien Mairal, and Zaid Harchaoui. A universal catalyst for first-order optimization. In Advances in Neural Information Processing Systems 28. 2015. ",
+        "bbox": [
+            173,
+            511,
+            821,
+            541
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Julien Mairal. Incremental majorization-minimization optimization with application to large-scale machine learning. Technical report, INRIA Grenoble Rhone-Alpes / LJK Laboratoire Jean Kuntz- ˆ mann, 2014. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            592
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sashank J. Reddi, Ahmed Hefny, Suvrit Sra, Barnabas P ´ ocz ´ os, and Alex Smola. Stochastic variance ´ reduction for nonconvex optimization. In Proceedings of the 33rd International Conference on International Conference on Machine Learning - Volume 48, ICML’16, 2016. ",
+        "bbox": [
+            171,
+            601,
+            821,
+            645
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mark Schmidt, Nicolas Le Roux, and Francis Bach. Minimizing finite sums with the stochastic average gradient. F. Math. Program., 2017. ",
+        "bbox": [
+            171,
+            652,
+            823,
+            683
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shai Shalev-Shwartz and Tong Zhang. Stochastic dual coordinate ascent methods for regularized loss minimization. Journal of Machine Learning Research, 14, 2013. ",
+        "bbox": [
+            171,
+            690,
+            823,
+            720
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shai Shalev-Shwartz and Tong Zhang. Accelerated proximal stochastic dual coordinate ascent for regularized loss minimization. Proceedings of the 31st International Conference on Machine Learning, 2014. ",
+        "bbox": [
+            174,
+            728,
+            823,
+            771
+        ],
+        "page_idx": 9
+    },
+    {
+        "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, 2014. ",
+        "bbox": [
+            173,
+            780,
+            823,
+            823
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016. ",
+        "bbox": [
+            173,
+            832,
+            823,
+            861
+        ],
+        "page_idx": 9
+    }
+]

parse/train/ByquB-WC-/ByquB-WC-.md

@@ -0,0 +1,256 @@
+# FINDING REMO (RELATED MEMORY OBJECT): A SIMPLE NEURAL ARCHITECTURE FOR TEXT BASED REASONING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+To solve the text-based question and answering task that requires relational reasoning, it is necessary to memorize a large amount of information and find out the question relevant information from the memory. Most approaches were based on external memory and four components proposed by Memory Network. The distinctive component among them was the way of finding the necessary information and it contributes to the performance. Recently, a simple but powerful neural network module for reasoning called Relation Network (RN) has been introduced. We analyzed RN from the view of Memory Network, and realized that its MLP component is able to reveal the complicate relation between question and object pair. Motivated from it, we introduce Relation Memory Network (RMN) which uses MLP to find out relevant information on Memory Network architecture. It shows new state-of-the-art results in jointly trained bAbI-10k story-based question answering tasks and bAbI dialog-based question answering tasks.
+
+# 1 INTRODUCTION
+
+Neural network has made an enormous progress on the two major challenges in artificial intelligence: seeing and reading. In both areas, embedding methods have served as the main vehicle to process and analyze text and image data for solving classification problems. As for the task of logical reasoning, however, more complex and careful handling of features is called for. A reasoning task requires the machine to answer a simple question upon the delivery of a series of sequential information. For example, imagine that the machine is given the following three sentences: “Mary got the milk there.”, “John moved to the bedroom.”, and “Mary traveled to the hallway.” Once prompted with the question, “Where is the milk?”, the machine then needs to sequentially focus on the two supporting sentences, “Mary got the milk there.” and “Mary traveled to the hallway.” in order to successfully determine that the milk is located in the hallway.
+
+Inspired by this reasoning mechanism, J. Weston & Bordes (2015) has introduced the memory network (MemNN), which consists of an external memory and four components: input feature map $( I )$ , generalization $( G )$ , output feature map $( O )$ , and response $( R )$ . The external memory enables the model to deal with a knowledge base without loss of information. Input feature map embeds the incoming sentences. Generalization updates old memories given the new input and output feature map finds relevant information from the memory. Finally, response produces the final output.
+
+Based on the memory network architecture, neural network based models like end-to-end memory network (MemN2N) (Sukhbaatar et al., 2015), gated end-to-end memory network (GMemN2N) (Liu & Perez, 2017), dynamic memory network (DMN) (Kumar et al., 2016), and dynamic memory network ${ \bf { \tau } } + \left( { \bf { D M N } } + \right)$ (Xiong et al., 2016) are proposed. Since strong reasoning ability depends on whether the model is able to sequentially catching the right supporting sentences that lead to the answer, the most important thing that discriminates those models is the way of constructing the output feature map. As the output feature map becomes more complex, it is able to learn patterns for more complicate relations. For example, MemN2N, which has the lowest performance among the four models, measures the relatedness between question and sentence by the inner product, while the best performing $\mathrm { D M N } +$ uses inner product and absolute difference with two embedding matrices.
+
+Recently, a new architecture called Relation Network (RN) (Santoro et al., 2017) has been proposed as a general solution to relational reasoning. The design philosophy behind it is to directly capture the supporting relation between the sentences through the multi-layer perceptron (MLP). Despite its simplicity, RN achieves better performance than previous models without any catastrophic failure.
+
+The interesting thing we found is that RN can also be interpreted in terms of MemNN. It is composed of $O$ and $R$ where each corresponds to MLP which focuses on the related pair and another MLP which infers the answer. RN does not need to have $G$ because it directly finds all the supporting sentences at once. In this point of view, the significant component would be MLP-based output feature map. As MLP is enough to recognize highly non-linear pattern, RN could find the proper relation better than previous models to answer the given question.
+
+However, as RN considers a pair at a time unlike MemNN, the number of relations that RN learns is $n ^ { 2 }$ when the number of input sentence is $n$ . When $n$ is small, the cost of learning relation is reduced by $n$ times compared to MemNN based models, which enables more data-efficient learning (Santoro et al., 2017). However, when $n$ increases, the performance becomes worse than the previous models. In this case, the pair-wise operation increases the number of non-related sentence pairs more than the related sentence pair, thereby confuses RN’s learning. Santoro et al. (2017) has suggested attention mechanisms as a solution to filter out unimportant relations; however, since it interrupts the reasoning operation, it may not be the most optimal solution to the problem.
+
+Our proposed model, “Relation Memory Network” (RMN), is able to find complex relation even when a lot of information is given. It uses MLP to find out relevant information with a new generalization which simply erase the information already used. In other words, RMN inherits RN’s MLP-based output feature map on Memory Network architecture. Experiments show its state-ofthe-art result on the text-based question answering tasks.
+
+# 2 RELATION MEMORY NETWORK
+
+![](images/7eb120fde291b9a161c8cd3ccc1faa79e9b5898e4acbbdd63cbcb76eaff370f1.jpg)  
+Figure 1: Relation Memory Network
+
+Relation Memory Network (RMN) is composed of four components - embedding, attention, updating, and reasoning. It takes as the inputs a set of sentences $\mathbf { x } _ { 1 } , \mathbf { x } _ { 2 } , . . . , \mathbf { x } _ { n }$ and its related question $\mathbf { u }$ , and outputs an answer a. Each of the $\mathbf { x } _ { i }$ , $\mathbf { u }$ , and a is made up of one-hot representation of words, for example, $\mathbf { x } _ { i } = \left\{ \mathbf { x } _ { i 1 } , \mathbf { x } _ { i 2 } , \mathbf { x } _ { i 3 } , . . . , \mathbf { x } _ { i n _ { i } } \right\}$ $( \mathbf { x } _ { i j } \in \mathbb { R } ^ { V } , j = ( \overset { \cdot } { 1 , 2 } , . . . , n _ { i } ) , V = \overset { \cdot } $ vocabulary size, $n _ { i } =$ number of words in sentence $i$ ).
+
+# 2.1 EMBEDDING COMPONENT
+
+We first embed words in each $\mathbf { x } _ { i } = \{ \mathbf { x } _ { i 1 } , \mathbf { x } _ { i 2 } , \mathbf { x } _ { i 3 } , . . . , \mathbf { x } _ { i n _ { i } } \}$ and $\mathbf { u }$ to a continuous space multiplying an embedding matrix $A \in \mathbb { R } ^ { d \times V }$ i. Then, the embedded sentence is stored and represented as a memory object $\mathbf { m } _ { i }$ while question is represented as $\mathbf { q }$ . Any of the following methods are available for embedding component: simple sum (equation 1), position encoding (J. Weston & Bordes, 2015) (equation 2), concatenation (equation 3), LSTM, and GRU. In case of LSTM or GRU, $\mathbf { m } _ { i }$ is the
+
+final hidden state of it.
+
+$$
+\mathbf { m } _ { i } = \sum _ { j } A \mathbf { x } _ { i j }
+$$
+
+$$
+\mathbf { m } _ { i } = \sum _ { j } l _ { j } \cdot A \mathbf { x } _ { i j } \quad ( l _ { k j } = ( 1 - j / n _ { i } ) - ( k / d ) ( 1 - 2 j / n _ { i } ) )
+$$
+
+$$
+\mathbf { m } _ { i } = [ A \mathbf { x } _ { i 1 } , A \mathbf { x } _ { i 2 } , \ldots , A \mathbf { x } _ { i n _ { i } } ]
+$$
+
+As the following attention component takes the concatenation of $\mathbf { m } _ { i }$ and $\mathbf { q }$ , it is not necessarily the case that sentence and question have the same dimensional embedding vectors unlike previous memory-augmented neural networks.
+
+# 2.2 ATTENTION COMPONENT
+
+Attention component can be applied more than once depending on the problem; Figure 1 illustrates 2 hop version of RMN. We refer to the $i ^ { t h }$ embedded sentence on the $t ^ { \mathit { \hat { t } h } }$ hop as $\mathbf { m } _ { i } ^ { \bar { t } }$ .
+
+To constitute the attention component, we applied simple MLP represented as $g _ { \theta } ^ { t }$ . It must be ended with 1 unit output layer to provide a scalar weight $\boldsymbol { w } _ { i } ^ { t }$ , which leads to an attention weight $\alpha _ { i } ^ { t }$ between 0 and 1. In the beginning, a vector concatenated with $\mathbf { m } _ { i } ^ { 1 }$ and $\mathbf { q }$ flows to the $g _ { \theta } ^ { 1 }$ . From the result of $g _ { \theta } ^ { 1 }$ , attention weight $\alpha _ { i } ^ { 1 }$ is calculated using additional variable $\beta ^ { 1 } \ ( \geq 1 )$ to control the intensity of attention, inspired by the way Neural Turing Machine (Graves et al., 2014) reads from the memory. Then we get the related memory object $\mathbf { r } ^ { 1 }$ , a weighted sum of $\alpha _ { i } ^ { 1 }$ and memory object $\mathbf { m } _ { i } ^ { 1 }$ for all $i$ . If there exist more hops, $\mathbf { r } ^ { 1 }$ is directly taken to the next hop and iterates over this process with the updated memory object $\mathbf { m } _ { i } ^ { 2 }$ . All the procedures are rewritten as equation 4, 5, and 6:
+
+$$
+\begin{array} { r l } { w _ { i } ^ { t }  g _ { \theta } ^ { t } ( [ \mathbf { m } _ { i } ^ { t } , \mathbf { r } ^ { t - 1 } ] ) } & { { } ( i = ( 1 , 2 , . . . , n ) , ~ \mathbf { r } ^ { 0 } = \mathbf { q } ) } \end{array}
+$$
+
+$$
+\alpha _ { i } ^ { t }  \frac { \exp ( \beta ^ { t } w _ { i } ^ { t } ) } { \sum _ { i } \exp ( \beta ^ { t } w _ { i } ^ { t } ) } \quad ( \beta ^ { t } ( z ) = 1 + \log ( 1 + \exp ( z ) ) )
+$$
+
+$$
+\mathbf { r } ^ { t }  \sum _ { i } { \boldsymbol { \alpha } _ { i } ^ { t } \cdot \mathbf { m } _ { i } ^ { t } }
+$$
+
+# 2.3 UPDATING COMPONENT
+
+To forget the information already used, we use intuitive updating component to renew the memory. It is replaced by the amount of unconsumed from the old one:
+
+$$
+\mathbf { m } _ { i } ^ { t + 1 } \gets ( 1 - \alpha _ { i } ^ { t } ) \mathbf { m } _ { i } ^ { t }
+$$
+
+Contrary to other components, updating is not a mandatory component. When it is considered to have 1 hop, there is no need to use this.
+
+# 2.4 REASONING COMPONENT
+
+Similar to attention component, reasoning component is also made up of MLP, represented as $f _ { \phi }$ . It receives both q and the final result of attention component $\mathbf { r } ^ { f }$ and then takes a softmax to produce the model answer aˆ:
+
+$$
+\hat { \mathbf { a } } \gets \mathrm { S o f t m a x } ( f _ { \phi } ( [ \mathbf { r } ^ { f } , \mathbf { q } ] ) )
+$$
+
+# 3 RELATED WORK
+
+# 3.1 MEMORY-AUGMENTED NEURAL NETWORK
+
+To answer the question from a given set of facts, the model needs to memorize these facts from the past. Long short term memory (LSTM) (Hochreiter & Schmidhuber, 1997), one of the variants of recurrent neural network (RNN), is inept at remembering past stories because of their small internal memory (Sukhbaatar et al., 2015). To cope with this problem, J. Weston & Bordes (2015) has proposed a new class of memory-augmented model called Memory Network (MemNN). MemNN comprises an external memory $m$ and four components: input feature map $( I )$ , generalization $( G )$ , output feature map $( O )$ , and response $( R )$ . $I$ encodes the sentences which are stored in memory $m$ . $G$ updates the memory, whereas $O$ reads output feature $o$ from the memory. Finally, $R$ infers an answer from $o$ .
+
+Table 1: MemN2N, RN, and RMN in terms of MemNN architecture   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Output feature map</td><td rowspan=1 colspan=1>Generalization</td></tr><tr><td rowspan=1 colspan=1>MemN2N</td><td rowspan=1 colspan=1>αt = Softmax(rt)Tmt)(r° = q)0t=∑amrt+1=ot+r²</td><td rowspan=1 colspan=1>mt = Wtmt-1</td></tr><tr><td rowspan=1 colspan=1>RN</td><td rowspan=1 colspan=1>ri = g0-MLP([mi,mj,q])0=∑iri</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>RMN</td><td rowspan=1 colspan=1>rt = g𝑠-MLP([m𝑡,rt-1])(r°=q)αt = Softmax(βtrt)rt=∑am</td><td rowspan=1 colspan=1>m²=(1-at-1)m+-1</td></tr></table>
+
+MemN2N, GMemN2N, DMN, and $\mathrm { D M N } +$ all follow the same structure of MemNN from a broad perspective, however, output feature map is composed in slightly different way. The relation between question and supporting sentences is realized from its cooperation. MemN2N first calculates the relatedness of sentences in the question and memory by taking the inner product, and the sentence with the highest relatedness is selected as the first supporting sentence for the given question. The first supporting sentence is then added with the question and repeat the same operation with the updated memory to find the second supporting sentence. GMemN2N selects the supporting sentence in the same way as MemN2N, but uses the gate to selectively add the the question to control the influence of the question information in finding the supporting sentence in the next step. DMN and $\mathrm { D M N } +$ use output feature map based on various relatedness such as absolute difference, as well as inner product, to understand the relation between sentence and question at various points.
+
+The more difficult the task, the more complex the output feature map and the generalization component to get the correct answer. For a dataset experimenting the text-based reasoning ability of the model, the overall accuracy could be increased in order of MemN2N, GMemN2N, DMN, and $\mathrm { D M N } +$ , where the complexity of the component increases.
+
+# 3.2 RELATION NETWORK
+
+Relation Network (RN) has emerged as a new and simpler framework for solving the general reasoning problem. RN takes in a pair of objects as its input and simply learns from the compositions of two MLPs represented as $g _ { \boldsymbol { \theta } }$ and $f _ { \phi }$ . The role of each MLP is not clearly defined in the original paper, but from the view of MemNN, it can be understood that $g _ { \theta }$ corresponds to $O$ and $f _ { \phi }$ corresponds to $R$ . Table 1 summarizes the interpretation of RN compared to MemN2N and our model, RMN.
+
+To verify the role of $g _ { \theta }$ , we compare the output when pairs are made with supporting sentences and when made with unrelated sentences. Figure 2 shows the visualization result of each output. When we focus on whether the value is activated or not, we can see that $g _ { \theta }$ distinguishes supporting sentence pair from non-supporting sentence pair as output feature map examines how relevant the sentence is to the question. Therefore, we can comprehend the output of $g _ { \theta }$ reveals the relation between the object pair and the question and $f _ { \phi }$ aggregates all these outputs to infer the answer.
+
+![](images/96576067658a24a913e1e947bf9e72e765bb3a9f087e37e9562f86f8289c928f.jpg)  
+Figure 2: The output vector of $g _ { \boldsymbol { \theta } }$ when the input objects are related and unrelated
+
+# 4 EXPERIMENTS
+
+# 4.1 DATASET
+
+bAbI story-based QA dataset bAbI story-based QA dataset (Weston et al., 2015) is composed of 20 different types of tasks for testing natural language reasoning ability. Each task requires different methods to infer the answer. The dataset includes a set of statements comprised of multiple sentences, a question and answer. A statement can be as short as two sentences and as long as 320 sentences. To answer the question, it is necessary to find relevant one or more sentences to a given question and derive answer from them. Answer is typically a single word but in a few tasks, answers are a set of words. Each task is regarded as success when the accuracy is greater than $9 5 \%$ . There are two versions of this dataset, one that has 1k training examples and the other with 10k examples. Most of the previous models test their accuracy on 10k dataset with trained jointly.
+
+bAbI dialog dataset bAbI dialog dataset (Bordes & Weston, 2016) is a set of 5 tasks within the goal-oriented context of restaurant reservation. It is designed to test if model can learn various abilities such as performing dialog management, querying knowledge bases (KBs), and interpreting the output of such queries. The KB can be queried using API calls and 4 fields (a type of cuisine, a location, a price range, and a party size). They should be filled to issue an API call. Task 1 tests the capacity of interpreting a request and asking the right questions to issue an API call. Task 2 checks the ability to modify an API call. Task 3 and 4 test the capacity of using outputs from an API call to propose options in the order of rating and to provide extra-information of what user asks for. Task 5 combines everything. The maximum length of the dialog for each task is different: 14 for task 1, 20 for task 2, 78 for task 3, 13 for task 4, and 96 for task 5. As restaurant name, locations, and cuisine types always face new entities, there are normal and OOV test sets to assess model’s generalization ability. Training sets consist fo 1k examples, which is not a large amount of creating realistic learning conditions.
+
+# 4.2 TRAINING DETAILS
+
+bAbI story-based QA dataset We trained 2 hop RMN jointly on all tasks using 10k dataset for model to infer the solution suited to each type of tasks. We limited the input to the last 70 stories for all tasks except task 3 for which we limited input to the last 130 stories, similar to Xiong et al. (2016) which is the hardest condition among previous models. Then, we labeled each sentence with its relative position. Embedding component is similar to Santoro et al. (2017), where story and question are embedded through different LSTMs; 32 unit word-lookup embeddings; 32 unit LSTM for story and question. For attention component, as we use 2 hop RMN, there are $\bar { g _ { \theta } ^ { 1 } }$ and $g _ { \theta } ^ { 2 }$ ; both are three-layer MLP consisting of 256, 128, 1 unit with ReLU activation function (Nair & Hinton, 2010). $f _ { \phi }$ is composed of 512, 512, and 159 units (the number of words appearing in bAbI dataset is 159) of three-layer MLP with ReLU non-linearities where the final layer was a linear that produced logits for a softmax over the answer vocabulary. For regularization, we use batch normalization (Ioffe & Szegedy, 2015) for all MLPs. The softmax output was optimized with a cross-entropy loss function using the Adam optimizer (Kingma & Ba, 2014) with a learning rate of $2 e ^ { - 4 }$ .
+
+bAbI dialog dataset We trained on full dialog scripts with every model response as answer, all previous dialog history as sentences to be memorized, and the last user utterance as question. Model selects the most probable response from 4,212 candidates which are ranked from a set of all bot utterances appearing in training, validation and test sets (plain and OOV) for all tasks combined. We also report results when we use match type features for dialog. Match type feature is an additional label on the candidates indicating if word is found on the dialog history. For example, if the world ‘Seoul’ is found, then the ‘location’ field is checked to hint model this word is important and should be used in API call. This feature can alleviate OOV problem. Training was done with Adam optimizer and a learning rate of $1 e ^ { - 4 }$ for all tasks. Additional model details are given in Appendix A.
+
+Table 2: Test error on bAbI story-based tasks with 10k training samples   
+
+<table><tr><td>Task</td><td>MemNN</td><td>MemN2N</td><td>GMemN2N</td><td>DMN</td><td>DMN+</td><td>DNC</td><td>EntNet1</td><td>RN2</td><td>RMN</td></tr><tr><td>1: Single Supporting Fact</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.1</td><td>0.0</td><td>0.0</td></tr><tr><td>2: Two Supporting Facts</td><td>0.0</td><td>0.3</td><td>0.0</td><td>1.8</td><td>0.3</td><td>0.4</td><td>2.8</td><td>8.3</td><td>0.5</td></tr><tr><td>3: Three Supporting Facts</td><td>0.0</td><td>9.3</td><td>4.5</td><td>4.8</td><td>1.1</td><td>1.8</td><td>10.6</td><td>17.1</td><td>14.7</td></tr><tr><td>4: Two Argument Relations</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>5:Three Argument Relations</td><td>2.0</td><td>0.6</td><td>0.2</td><td>0.7</td><td>0.5</td><td>0.8</td><td>0.4</td><td>0.7</td><td>0.4</td></tr><tr><td>6:Yes/No Questions</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.3</td><td>0.0</td><td>0.0</td></tr><tr><td>7: Counting</td><td>15.0</td><td>3.7</td><td>1.8</td><td>3.1</td><td>2.4</td><td>0.6</td><td>0.8</td><td>0.4</td><td>0.5</td></tr><tr><td>8: Lists/Sets</td><td>9.0</td><td>0.8</td><td>0.3</td><td>3.5</td><td>0.0</td><td>0.3</td><td>0.1</td><td>0.3</td><td>0.3</td></tr><tr><td>9: Simple Negation</td><td>0.0</td><td>0.8</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.2</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>10: Indefinite Knowledge</td><td>2.0</td><td>2.4</td><td>0.2</td><td>2.5</td><td>0.0</td><td>0.2</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>11:Basic Coreference</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.1</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.4</td><td>0.5</td></tr><tr><td>12:Conjunction</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>13:Compound Coreference</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.2</td><td>0.0</td><td>0.1</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>14: Time Reasoning</td><td>1.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.4</td><td>3.6</td><td>0.0</td><td>0.0</td></tr><tr><td>15:Basic Deduction</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>16: Basic Induction</td><td>0.0</td><td>0.4</td><td>0.0</td><td>0.6</td><td>45.3</td><td>33.1</td><td>52.1</td><td>4.9</td><td>0.9</td></tr><tr><td>17: Positional Reasoning</td><td>35.0</td><td>40.7</td><td>27.8</td><td>40.4</td><td>4.2</td><td>12.0</td><td>11.7</td><td>1.6</td><td>0.3</td></tr><tr><td>18:Size Reasoning</td><td>5.0</td><td>6.7</td><td>8.5</td><td>4.7</td><td>2.1</td><td>0.8</td><td>2.1</td><td>2.1</td><td>2.3</td></tr><tr><td>19:Path Finding</td><td>64.0</td><td>66.5</td><td>31.0</td><td>65.5</td><td>0.0</td><td>3.9</td><td>63.0</td><td>3.2</td><td>2.9</td></tr><tr><td>20:Agent&#x27;s Motivations</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>Mean error (%)</td><td>6.7</td><td>6.6</td><td>3.7</td><td>6.4</td><td>2.8</td><td>2.7</td><td>7.4</td><td>2.0</td><td>1.2</td></tr><tr><td>Failed tasks (err. &gt;5%)</td><td>4</td><td>4</td><td>3</td><td>2</td><td>1</td><td>2</td><td>4</td><td>2</td><td>1</td></tr></table>
+
+Table 3: bAbI story-based task visualization of $\alpha$   
+(c) Task 3   
+
+<table><tr><td rowspan=1 colspan=1>Seq.</td><td rowspan=1 colspan=1>Task3:Three Supporting Facts</td><td rowspan=1 colspan=1>α1</td><td rowspan=1 colspan=1>a²</td></tr><tr><td></td><td rowspan=8 colspan=1>Daniel took the football.Sandra travelled to the bedroom .Daniel moved to the bathroom.Sandra got the milk .Daniel travelled to the garden.Daniel went to the hallway .Daniel put down the apple .Daniel put down the football there .</td><td rowspan=1 colspan=1>0.46</td><td rowspan=1 colspan=1>0.01</td></tr><tr><td rowspan=1 colspan=1>39</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.00</td></tr><tr><td rowspan=6 colspan=1>404142465051</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.31</td></tr><tr><td rowspan=1 colspan=1>0.00</td><td rowspan=1 colspan=1>0.00</td></tr><tr><td rowspan=1 colspan=1>0.04</td><td rowspan=1 colspan=1>0.42</td></tr><tr><td rowspan=1 colspan=1>0.00</td><td rowspan=1 colspan=1>0.25</td></tr><tr><td rowspan=1 colspan=1>0.00</td><td rowspan=1 colspan=1>0.01</td></tr><tr><td rowspan=1 colspan=1>0.38</td><td rowspan=1 colspan=1>0.00</td></tr><tr><td rowspan=1 colspan=1>User input</td><td rowspan=1 colspan=3>Where was the football before the garden ?</td></tr><tr><td rowspan=1 colspan=1>Answer</td><td rowspan=1 colspan=3>Bathroom</td></tr><tr><td rowspan=1 colspan=1>Modelanswer</td><td rowspan=1 colspan=3>Bathroom                    [Correct]</td></tr><tr><td rowspan=1 colspan=1>Seq.</td><td rowspan=1 colspan=1>Task3:Three SupportingFacts</td><td rowspan=1 colspan=1>a</td><td rowspan=1 colspan=1>a2</td></tr><tr><td rowspan=6 colspan=1>1356111214</td><td rowspan=6 colspan=1>Mary got the football.Mary picked up the football.Mary moved to the office.Mary went to the hallway.Mary travelled to the garden .Mary travelled to the kitchen .Mary moved to the office .</td><td rowspan=1 colspan=1>0.26</td><td rowspan=1 colspan=1>0.00</td></tr><tr><td rowspan=1 colspan=1>0.39</td><td rowspan=1 colspan=1>0.00</td></tr><tr><td rowspan=1 colspan=1>0.00</td><td rowspan=1 colspan=1>0.05</td></tr><tr><td rowspan=1 colspan=1>0.00</td><td rowspan=1 colspan=1>0.21</td></tr><tr><td rowspan=1 colspan=1>0.00</td><td rowspan=1 colspan=1>0.29</td></tr><tr><td rowspan=1 colspan=1>0.00</td><td rowspan=1 colspan=1>0.25</td></tr><tr><td rowspan=2 colspan=1>1622</td><td rowspan=2 colspan=1>Mary went to the garden .Mary discarded the football there .</td><td rowspan=1 colspan=1>0.00</td><td rowspan=1 colspan=1>0.05</td></tr><tr><td rowspan=1 colspan=1>0.24</td><td rowspan=1 colspan=1>0.00</td></tr><tr><td rowspan=1 colspan=1>User input</td><td rowspan=1 colspan=3>Where was the football before the garden ?</td></tr><tr><td rowspan=1 colspan=1>Answer</td><td rowspan=1 colspan=3>Office</td></tr><tr><td rowspan=1 colspan=1>Model answer</td><td rowspan=1 colspan=3>Kitchen                    [Incorrect]</td></tr></table>
+
+(a) Task 7   
+
+<table><tr><td>Seq.</td><td>Task 7:Counting</td><td>a1</td><td>α²</td></tr><tr><td>8</td><td>John grabbed the apple there.</td><td>0.02</td><td>0.00</td></tr><tr><td>9</td><td>John gave the apple to Mary.</td><td>0.08</td><td>0.16</td></tr><tr><td>10</td><td>Mary passed the apple to John .</td><td>0.17</td><td>0.24</td></tr><tr><td>11</td><td>Mary journeyed to the hallway .</td><td>0.00</td><td>0.01</td></tr><tr><td>13</td><td>Sandra went to the garden .</td><td>0.00</td><td>0.00</td></tr><tr><td>14</td><td>Mary went to the kitchen .</td><td>0.00</td><td>0.03</td></tr><tr><td>15</td><td>Mary picked up the football there .</td><td>0.29</td><td>0.24</td></tr><tr><td>16</td><td>Mary picked up the milk there .</td><td>0.27</td><td>0.32</td></tr><tr><td>User input</td><td colspan="3">Howmany objectsisMarycarrying?</td></tr><tr><td>Answer</td><td colspan="3">Two</td></tr><tr><td>Model answer</td><td>Two</td><td colspan="2">[Correct]</td></tr></table>
+
+(b) Task 14   
+
+<table><tr><td>Seq.</td><td>Task14:Timereasoning</td><td>a1</td><td>a²</td></tr><tr><td>1</td><td>Marywent back to the school yesterday.</td><td>0.00</td><td>0.01</td></tr><tr><td>2</td><td>Fred went to the school yesterday</td><td>0.00</td><td>0.00</td></tr><tr><td>3</td><td>Julie went back to the kitchen yesterday .</td><td>0.13</td><td>0.98</td></tr><tr><td>4</td><td>Fred journeyed to the kitchen this morning</td><td>0.00</td><td>0.00</td></tr><tr><td>5</td><td>This morning julie journeyed to the school .</td><td>0.66</td><td>0.02</td></tr><tr><td>6</td><td>This evening mary went back to the school .</td><td>0.01</td><td>0.00</td></tr><tr><td>7</td><td>This afternoon julie went to the bedroom .</td><td>0.06</td><td>0.00</td></tr><tr><td>User input</td><td>Wherewas Julie before theschool ?</td><td></td><td></td></tr><tr><td>Answer</td><td>Kitchen</td><td colspan="2"></td></tr><tr><td>Model answer</td><td>Kitchen</td><td colspan="2">[Correct]</td></tr></table>
+
+# 5 RESULTS AND DISCUSSION
+
+# 5.1 BABI STORY-BASED QA
+
+As we can see in table 2, RMN shows state-of-the-art result on bAbI story-based Question Answering dataset: $9 8 . 8 \%$ accuracy where only a single task with no catastrophic failure. It succeeded on task 17, 18, 19 where MemN2N, GMemN2N, and DMN are failed to solve, and on task 16 which $\mathrm { D M N } +$ , DNC, and EntNet scored high error rates.
+
+Table 3 shows how our model solved several tasks. RMN’s attention component $g _ { \theta } ^ { 1 }$ and $g _ { \theta } ^ { 2 }$ complement each other to identify the necessary facts to answer correctly. Sometimes both $g _ { \theta } ^ { 1 }$ and $g _ { \theta } ^ { 2 }$ concentrate on the same sentences which are all critical to answer the question, and sometimes $g _ { \theta } ^ { 1 }$ finds a fact related to the given question and with this information $g _ { \theta } ^ { 2 }$ chooses the key fact to answer. While trained jointly, RMN learns these different solutions for each task. For the task 3, the only failed task, attention component still functions well; it focuses sequentially on the supporting sentences. However, the reasoning component, $f _ { \phi }$ , had difficulty catching the word ‘before’. We could easily figure out ‘before’ implies ‘just before’ the certain situation, whereas RMN confused its meaning. As shown in table 3c, our model found all previous locations before the garden. Still, it is remarkable that the simple MLP carried out all of these various roles.
+
+# 5.2 BABI DIALOG
+
+Table 4: Test error on bAbI dialog tasks 3   
+
+<table><tr><td rowspan="2">Task</td><td colspan="4">Plain</td><td colspan="4">WithMatch</td></tr><tr><td>MemN2N</td><td>GMemN2N</td><td>RN4</td><td>RMN</td><td>MemN2N</td><td>GMemN2N</td><td>RN4</td><td>RMN</td></tr><tr><td>1: Issuing API calls</td><td>0.1</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>2: Updating API calls</td><td>0.0</td><td>0.0</td><td>0.5</td><td>0.0</td><td>1.7</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>3:Displaying options</td><td>25.1</td><td>25.1</td><td>26.6</td><td>25.1</td><td>25.1</td><td>25.1</td><td>27.1</td><td>25.1</td></tr><tr><td>4: Providing extra information</td><td>40.5</td><td>42.8</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>5: Conducting full dialogs</td><td>3.9</td><td>3.7</td><td>23.3</td><td>2.5</td><td>6.6</td><td>2.0</td><td>16.6</td><td>1.8</td></tr><tr><td>Average error rates(%)</td><td>13.9</td><td>14.3</td><td>10.1</td><td>5.5</td><td>6.7</td><td>5.4</td><td>8.7</td><td>5.4</td></tr><tr><td>1 (OOV): Issuing API calls</td><td>27.7</td><td>17.6</td><td>17.8</td><td>16.8</td><td>3.5</td><td>0.0</td><td>1.5</td><td>0.0</td></tr><tr><td>2 (OOV): Updatining API calls</td><td>21.1</td><td>21.1</td><td>23.2</td><td>21.1</td><td>5.5</td><td>5.8</td><td>0.0</td><td>0.0</td></tr><tr><td>3(OOV): Displaying options</td><td>25.6</td><td>24.7</td><td>27.2</td><td>24.9</td><td>24.8</td><td>24.9</td><td>29.8</td><td>25.1</td></tr><tr><td>4(OOV): Providing extra information</td><td>42.4</td><td>43.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>5(OOV): Conducting full dialogs</td><td>34.5</td><td>33.3</td><td>38.3</td><td>34.5</td><td>22.3</td><td>20.6</td><td>28.4</td><td>21.7</td></tr><tr><td>Average error rates (%)</td><td>30.3</td><td>27.9</td><td>21.3</td><td>19.5</td><td>11.2</td><td>10.3</td><td>12.0</td><td>9.4</td></tr></table>
+
+The results in the Table 4 show that the RMN has the best results in any conditions. Without any match type, RN and RMN outperform previous memory-augmented models on both normal and OOV tasks. This is mainly attributed to the impressive result on task 4 which can be interpreted as an effect of MLP based output feature map.
+
+To solve task 4, it is critical to understand the relation between ‘phone number’ of user input and ‘r phone’ of previous dialog as shown in Table 8c. We assumed that inner product was not sufficient to capture their implicit similarity and performed an supporting experiment. We converted RMN’s attention component to inner product based attention, and the results revealed the error rate increased to $1 1 . 3 \%$ .
+
+For the task 3 and task 5 where the maximum length is especially longer than the others, RN performs worse than MemN2N, GMemN2N and RMN. The number of unnecessary object pairs created by the RN not only increases the processing time but also decreases the accuracy.
+
+With the match type feature, all models other than RMN have significantly improved their performance except for task 3 compared to the plain condition. RMN was helped by the match type only on the OOV tasks and this implies RMN is able to find relation in the With Match condition for the normal tasks.
+
+When we look at the OOV tasks more precisely, RMN failed to perform well on the OOV task 1 and 2 even though $g _ { \theta } ^ { 1 }$ properly focused on the related object as shown in Table 8a. We state that this originated from the fact that the number of keywords in task 1 and 2 is bigger than that in task 4. In task 1 and 2, all four keywords (cuisine, location, number and price) must be correctly aligned from the supporting sentence in order to make the correct API call which is harder than task 4. Consider the example in Table 8a and Table 8c. Supporting sentence of task 4 have one keyword out of three words, whereas supporting sentences of task 1 and 2 consist of four keywords (cuisine, location, number and price) out of sixteen words.
+
+Different from other tasks, RMN yields the same error rate $2 5 . 1 \%$ with MemN2N and GMemN2N on the task 3. The main goal of task 3 is to recommend restaurant from knowledge base in the order of rating. All failed cases are displaying restaurant where the user input is <silence>which is somewhat an ambiguous trigger to find the input relevant previous utterance. As shown in Table 8b, there are two different types of response to the same user input. One is to check whether all the required fields are given from the previous utterances and then ask user for the missing fields or send a “Ok let me look into some options for you.” message. The other type is to recommend restaurant starting from the highest rating. All models show lack of ability to discriminate these two types of silences so that concluded to the same results. To verify our statement, we performed an additional experiment on task 3 and checked the performance gain (extra result is given in Table 10 of Appendix B).
+
+# 5.3 MODEL ANALYSIS
+
+Effectiveness of the MLP-based output feature map The most important feature that distinguishes MemNN based models is the output feature map. Table 5 summarizes the experimental results for the bAbI story-based QA dataset when replacing the RMN’s MLP-based output feature map with the idea of the previous models. inner product was used in MemN2N, inner product with gate was used in GMemN2N, and inner product and absolute difference with two embedding matrices was used in DMN and $\mathrm { D M N } +$ . From the Table 5, the more complex the output feature map, the better the overall performance. In this point of view, MLP is the effective output feature map.
+
+Table 5: Test error of RMN on bAbI story-based QA dataset with different configurations   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>inner product</td><td rowspan=1 colspan=1> inner product with gate</td><td rowspan=1 colspan=1>inner product and absolute differencewith two embedding matrices</td><td rowspan=1 colspan=1>MLP</td></tr><tr><td rowspan=1 colspan=1>error rate</td><td rowspan=1 colspan=1>29.4</td><td rowspan=1 colspan=1>25.9</td><td rowspan=1 colspan=1>11.2</td><td rowspan=1 colspan=1>1.2</td></tr></table>
+
+Performance of RN and RMN according to memory size Additional experiments were conducted with the bAbI story-based QA dataset to see how memory size affects both performance and training time of RN and RMN. Test errors with training time written in parentheses are summarized in Table 6.
+
+When memory size is small, we could observe the data-effeciency of RN. It shows similar performance to RMN in less time. However, when the memory size increases, performance is significantly reduced compared to RMN, even though it has been learned for a longer time. It is even lower than itself when the memory size is 20. On the other hand, RMN maintains high performance even when the memory size increases.
+
+Table 6: Test error and training time of RN and RMN on bAbI story-based QA dataset with different memory size   
+
+<table><tr><td rowspan=1 colspan=1>memory size</td><td rowspan=1 colspan=1>RN</td><td rowspan=1 colspan=1>RMN</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>2.0 (0.65 days)</td><td rowspan=1 colspan=1>1.5 (1.46 days)</td></tr><tr><td rowspan=1 colspan=1>130</td><td rowspan=1 colspan=1>9.8 (9.47 days)</td><td rowspan=1 colspan=1>1.2 (4.94 days)</td></tr></table>
+
+Effectiveness of the number of hops bAbI story based QA dataset differs in the number of supporting sentences by each task that need to be referenced to solve problems. For example, task 1, 2, and 3 require single, two, and three supporting facts, respectively. The result of the mean error rate for each task according to the number of hops is in Table 7.
+
+Overall, the number of hops is correlated with the number of supporting sentences. In this respect, when the number of relations increases, RMN could reason across increasing the number of hops to 3, 4 or more.
+
+Table 7: Test error of RMN on bAbI story-based QA dataset with different number of hops   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>hop 1</td><td rowspan=1 colspan=1>hop 2</td><td rowspan=1 colspan=1>hop 3</td></tr><tr><td rowspan=1 colspan=1>task 1 (1)</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>0.2</td></tr><tr><td rowspan=1 colspan=1>task 2 (2)</td><td rowspan=1 colspan=1>62.0</td><td rowspan=1 colspan=1>0.5</td><td rowspan=1 colspan=1>2.1</td></tr><tr><td rowspan=1 colspan=1>task 3 (3)</td><td rowspan=1 colspan=1>62.4</td><td rowspan=1 colspan=1>14.7</td><td rowspan=1 colspan=1>14.6</td></tr><tr><td rowspan=1 colspan=1>task 10 (1)</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>3.6</td></tr></table>
+
+5Number in parentheses indicates the number of supporting sentences to solve the task
+
+# 6 CONCLUSION
+
+Our work, RMN, is a simple and powerful architecture that effectively handles text-based question answering tasks when large size of memory and high reasoning ability is required. Multiple access to the external memory to find out necessary information through a multi-hop approach is similar to most existing approaches. However, by using a MLP that can effectively deal with complex relatedness when searching for the right supporting sentences among a lot of sentences, RMN raised the state-of-the-art performance on the story-based QA and goal-oriented dialog dataset. When comparing RN which also used MLP to understand relations, RMN was more effective in the case of large memory.
+
+Future work will apply RMN to image based reasoning task (e.g., CLEVR, DAQUAR, VQA etc.). To extract features from the image, VGG net (Simonyan & Zisserman, 2014) is used in convention and outputs 196 objects of 512 dimensional vectors which also require large sized memory. An important direction will be to find an appropriate way to focus sequentially on related object which was rather easy in text-based reasoning.
+
+# (a) Plain and OOV result of task 1
+
+Table 8: Visualization of $\alpha$ on bAbI dialog task 1, 3, and 4 without match type   
+
+<table><tr><td>Seq.</td><td>Locutor</td><td>Task 1: Issuing API calls</td><td>a1</td></tr><tr><td>1 2</td><td>user</td><td>Good morning Hello what can i help you with today</td><td>0.01</td></tr><tr><td></td><td>bot</td><td></td><td>0.01</td></tr><tr><td>3</td><td>user</td><td>Can you make restaurant reservation for eight people in cheap price range with british cuisine</td><td>0.23</td></tr><tr><td>4</td><td>bot</td><td>I&#x27;m on it</td><td>0.00</td></tr><tr><td>5</td><td>user</td><td>&lt;silence&gt;</td><td>0.14</td></tr><tr><td>6</td><td>bot</td><td>Where should it be</td><td>0.01</td></tr><tr><td>7</td><td>user</td><td>In madrid</td><td>0.25</td></tr><tr><td>8</td><td>bot</td><td>Ok let me look into some options for you</td><td>0.18</td></tr><tr><td colspan="2">User input</td><td>&lt;silence&gt;</td><td></td></tr><tr><td colspan="2">Answer</td><td>API_call british madrid eight cheap</td><td></td></tr><tr><td colspan="2">Modelanswer</td><td>API_call british madrid eight cheap [Correct]</td><td></td></tr><tr><td>Seq.</td><td>Locutor</td><td>Task1(OOV):IssuingAPIcalls</td><td>α1</td></tr><tr><td>1</td><td>user</td><td>Hi</td><td>0.01</td></tr><tr><td>2</td><td>bot</td><td>Hello what can i help you with today</td><td>0.01</td></tr><tr><td>3 4</td><td>user bot</td><td>May Ihave table with cantonese cuisine in cheap price range in seoul for two people</td><td>0.49</td></tr><tr><td>5</td><td>user</td><td>I&#x27;m on it &lt;silence&gt;</td><td>0.10</td></tr><tr><td>6</td><td>bot</td><td></td><td>0.01 0.27</td></tr><tr><td>User input</td><td></td><td>Ok let me look into some options for you</td><td></td></tr><tr><td colspan="2">Answer</td><td>&lt;silence&gt; API_call cantonese seoul two cheap</td><td></td></tr><tr><td colspan="2">Model answer</td><td>API_call italian paris two cheap</td><td></td></tr></table>
+
+# (b) Same user input with different goal in task 3
+
+<table><tr><td>Seq.</td><td>Locutor</td><td>Task 3:Displaying options</td><td>aT</td></tr><tr><td rowspan="5">7 14 21 22 23</td><td rowspan="5">user user user user bot</td><td>resto_l rrating1 resto_8 rrating 8</td><td rowspan="2">0.01 0.01 0.01 0.01 0.01</td></tr><tr><td></td></tr><tr><td>resto.3 r_rating 3</td><td></td></tr><tr><td>Hello</td><td></td></tr><tr><td>Hello what can i help you with today Can you book table with french food for two people in madrid in moderate price range I&#x27;m on it</td><td>0.21</td></tr><tr><td colspan="2">24 user 25 bot</td></tr><tr><td colspan="2">User input &lt;silence&gt; Answer Where should it be?</td><td colspan="2"></td></tr><tr><td colspan="2">Model answer</td><td colspan="3">Whereshould itbe? [Correct]</td></tr><tr><td>Seq.</td><td>Locutor</td><td>Task3:Displayingoptions</td><td>a1</td></tr><tr><td>7</td><td>user</td><td>resto_l rrating 1</td><td>0.00</td></tr><tr><td>14</td><td>user user</td><td>resto_8 rrating 8 resto_3 r_rating 3</td><td>0.00</td></tr><tr><td>24</td><td>user</td><td>Can you book table with french food for two people in madrid in moderate price range</td><td>0.00 0.14</td></tr><tr><td></td><td>bot</td><td></td><td></td></tr><tr><td>252627</td><td>user</td><td>I&#x27;m on it</td><td>0.00</td></tr><tr><td></td><td>bot</td><td>&lt;silence&gt;</td><td>0.09</td></tr><tr><td></td><td>user</td><td>Ok let me look into some options for you</td><td>0.15</td></tr><tr><td>28</td><td>bot</td><td>&lt;silence&gt;</td><td>0.10</td></tr><tr><td>29</td><td>user</td><td>What do you think of this option : resto_8</td><td>0.08</td></tr><tr><td>30</td><td>bot</td><td>No this does not work for me</td><td>0.06</td></tr><tr><td>31</td><td></td><td>Sure let me find other option for you</td><td>0.08</td></tr><tr><td colspan="2">User input</td><td>&lt;silence&gt;</td><td></td></tr><tr><td colspan="2">Answer</td><td>What do you think of this option: resto.3</td><td colspan="2"></td></tr><tr><td colspan="2">Modelanswer</td><td colspan="3">Whatdo you think of thisoption:resto_7 [Incorrect]</td></tr></table>
+
+# (c) Plain and OOV result of task 4
+
+<table><tr><td>Seq.</td><td>Locutor</td><td>Task4:Providingextrainformation</td><td>α1</td><td></td></tr><tr><td>1</td><td>user</td><td>resto_3r_phone resto_3_phone</td><td></td><td>0.77</td></tr><tr><td>3</td><td>user</td><td>resto_3 r_addressresto_3_address</td><td></td><td>0.01</td></tr><tr><td>4</td><td>user</td><td>resto_3 r_location london</td><td></td><td>0.01</td></tr><tr><td>6</td><td>user</td><td>resto.3 r-price cheap</td><td></td><td>0.01</td></tr><tr><td>10</td><td>user</td><td>I&#x27;d like to book table at resto_3</td><td></td><td>0.02</td></tr><tr><td>11</td><td>bot</td><td>Great let me do reservation</td><td></td><td>0.03</td></tr><tr><td colspan="2">User input</td><td colspan="3">Whatis phone number of restaurant?</td></tr><tr><td colspan="2">Answer</td><td colspan="3">Hereitis:resto_3_phone</td></tr><tr><td colspan="2">Model answer</td><td colspan="3">Here itis:resto_3_phone [Correct]</td></tr><tr><td>Seq.</td><td>Locutor</td><td>Task 4(OOV):Providingextra information</td><td></td><td>a1</td></tr><tr><td>1</td><td>user</td><td>resto_1 r-phone resto_l-phone</td><td></td><td>0.79</td></tr><tr><td>3</td><td>user</td><td>resto_1 r_address resto_1_address</td><td></td><td>0.01</td></tr><tr><td>4</td><td>user</td><td>resto_lr_location hanoi</td><td></td><td>0.01</td></tr><tr><td>6</td><td>user</td><td>resto_1 r_price expensive</td><td></td><td>0.01</td></tr><tr><td>10</td><td>user</td><td>Can you make restaurant reservation at resto_1</td><td></td><td>0.01</td></tr><tr><td>11</td><td>bot</td><td>Great let me do reservation</td><td></td><td>0.04</td></tr><tr><td colspan="2">User input</td><td>Whatisphone number of restaurant?</td><td colspan="2"></td></tr><tr><td colspan="2">Answer</td><td>Here itis:resto_l_phone</td><td colspan="2"></td></tr><tr><td colspan="2">Model answer</td><td colspan="3">Here it is:resto_1_phone [Correct]</td></tr></table>
+
+# REFERENCES
+
+Antoine Bordes and Jason Weston. Learning end-to-end goal-oriented dialog. CoRR, abs/1605.07683, 2016.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448– 456, 2015.
+
+S. Chopra J. Weston and A. Bordes. Memory networks. International Conference on Learning Representations (ICLR), 2015.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Ankit Kumar, Ozan Irsoy, Peter Ondruska, Mohit Iyyer, James Bradbury, Ishaan Gulrajani, Victor Zhong, Romain Paulus, and Richard Socher. Ask me anything: Dynamic memory networks for natural language processing. In International Conference on Machine Learning, pp. 1378–1387, 2016.
+
+Fei Liu and Julien Perez. Gated end-to-end memory networks. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 1, Long Papers, volume 1, pp. 1–10, 2017.
+
+Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th international conference on machine learning (ICML-10), pp. 807–814, 2010.
+
+Adam Santoro, David Raposo, David GT Barrett, Mateusz Malinowski, Razvan Pascanu, Peter Battaglia, and Timothy Lillicrap. A simple neural network module for relational reasoning. Advances in neural information processing systems, 2017.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Sainbayar Sukhbaatar, Jason Weston, Rob Fergus, et al. End-to-end memory networks. In Advances in neural information processing systems, pp. 2440–2448, 2015.
+
+Jason Weston, Antoine Bordes, Sumit Chopra, and Tomas Mikolov. Towards ai-complete question answering: A set of prerequisite toy tasks. CoRR, abs/1502.05698, 2015.
+
+Caiming Xiong, Stephen Merity, and Richard Socher. Dynamic memory networks for visual and textual question answering. In International Conference on Machine Learning, pp. 2397–2406, 2016.
+
+# A MODEL DETAILS
+
+Table 9: Hyperparameters of Relation Memory Networks on bAbI dialog tasks   
+
+<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>Story and QuestionEmbedding</td><td rowspan=1 colspan=1>Word-lookupEmbedding Dim</td><td rowspan=1 colspan=1>Hop</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>f</td><td rowspan=1 colspan=1>Activation</td><td rowspan=1 colspan=1>Use Batch Norm</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>sum</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2048,2048,1</td><td rowspan=1 colspan=1>2048,2048,4212</td><td rowspan=1 colspan=1>tanh</td><td rowspan=1 colspan=1>True</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>sum</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1024,1024,1</td><td rowspan=1 colspan=1>1024，1024,4212</td><td rowspan=1 colspan=1>tanh</td><td rowspan=1 colspan=1>True</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>sum</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1024，1024,1024，1</td><td rowspan=1 colspan=1>1024，1024，1024，4212</td><td rowspan=1 colspan=1>tanh</td><td rowspan=1 colspan=1>True</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>concatenation</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1024,1024,1</td><td rowspan=1 colspan=1>1024，1024,4212</td><td rowspan=1 colspan=1>tanh</td><td rowspan=1 colspan=1>True</td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>concatenation</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>4096,4096,1</td><td rowspan=1 colspan=1>4096,4096,4212</td><td rowspan=1 colspan=1>tanh</td><td rowspan=1 colspan=1>True</td></tr></table>
+
+# B ADDITIONAL RESULTS
+
+Table 10: Visualization of $\alpha ^ { 1 }$ and $\alpha ^ { 2 }$ on user input revised bAbI dialog task 3 without match type
+
+<table><tr><td>Seq.</td><td>Locutor</td><td>Task 3:Displaying options</td><td>α1</td><td>α²</td></tr><tr><td>1</td><td>user</td><td>resto_8 r_phone resto_8_phone</td><td>0.00</td><td>0.01</td></tr><tr><td></td><td>user</td><td>resto_8 r_cuisine french</td><td>0.01</td><td>0.01</td></tr><tr><td></td><td>user</td><td>resto_8 r_address resto_8_address</td><td>0.01</td><td>0.01</td></tr><tr><td></td><td>user</td><td>resto_8 r_location madrid</td><td>0.01</td><td>0.01</td></tr><tr><td>２３456</td><td>user</td><td>resto_8 r_number two</td><td>0.00</td><td>0.01</td></tr><tr><td></td><td>user</td><td>resto_8 r_price moderate</td><td>0.00</td><td>0.01</td></tr><tr><td>78</td><td>user</td><td>resto_8 r_rating 8</td><td>0.01</td><td>0.39</td></tr><tr><td></td><td>user</td><td>resto.3 r_phone resto-3_phone</td><td>0.01</td><td>0.01</td></tr><tr><td>9</td><td>user</td><td>resto.3 r_cuisine french</td><td>0.00</td><td>0.01</td></tr><tr><td>10</td><td>user</td><td>resto_3 r_address resto_3_address</td><td>0.00</td><td>0.01</td></tr><tr><td>11</td><td>user</td><td>resto_3 r_location madrid</td><td>0.00</td><td>0.01</td></tr><tr><td>12</td><td>user</td><td>resto.3 r_number two</td><td>0.00</td><td>0.01</td></tr><tr><td>13</td><td>user</td><td>resto_3 r_price moderate</td><td>0.00</td><td>0.01</td></tr><tr><td>14</td><td>user</td><td>resto_3 rrating 3</td><td>0.00</td><td>0.01</td></tr><tr><td>15</td><td>user</td><td>resto_l r_phone resto_l_phone</td><td>0.01</td><td>0.01</td></tr><tr><td>16</td><td>user</td><td>resto_l r_cuisine french</td><td>0.01</td><td>0.01</td></tr><tr><td>17</td><td>user</td><td>resto_l r_address resto_l_address</td><td>0.01</td><td>0.01</td></tr><tr><td>18</td><td>user</td><td>resto_1 r_location madrid</td><td>0.01</td><td>0.01</td></tr><tr><td>19</td><td>user</td><td>resto_1 r_number two</td><td>0.00</td><td>0.01</td></tr><tr><td></td><td>user</td><td>resto_l r-price moderate</td><td>0.00</td><td>0.01</td></tr><tr><td></td><td>user</td><td>resto_l rrating 1</td><td>0.00</td><td>0.01</td></tr><tr><td></td><td>user</td><td>Good morning</td><td>0.01</td><td>0.01</td></tr><tr><td></td><td>bot</td><td>Hello what can I help you with today?</td><td>0.12</td><td>0.01</td></tr><tr><td>202122324252627282930</td><td>user</td><td>May Ihave table for two with french food?</td><td>0.08</td><td>0.02</td></tr><tr><td></td><td>bot</td><td>I&#x27;m on it</td><td>0.03</td><td>0.01</td></tr><tr><td></td><td>user</td><td>&lt;silence&gt;</td><td>0.01</td><td>0.01</td></tr><tr><td></td><td>bot</td><td>Where should it be</td><td>0.09</td><td>0.01</td></tr><tr><td></td><td>user</td><td>In madrid</td><td>0.01</td><td>0.01</td></tr><tr><td></td><td>bot</td><td>Which price range are looking for?</td><td>0.09</td><td>0.01</td></tr><tr><td></td><td>user</td><td>In moderate price range please</td><td>0.01</td><td>0.01</td></tr><tr><td>31</td><td>bot</td><td>Ok let me look into some options for you</td><td>0.24</td><td>0.01</td></tr><tr><td colspan="2">User input</td><td colspan="3">&lt;silence&gt;&lt;silence&gt;</td></tr><tr><td colspan="2">Answer</td><td colspan="3">What do you think of this option: resto_8</td></tr><tr><td colspan="2">Model answer</td><td colspan="3">What do you think of this option: resto_8 [correct]</td></tr></table>
+
+We modify the user input from $<$ silence $>$ to $<$ <silence> $<$ <silence $>$ when looking for restaurant recommendations. This makes model to distinguish two different situations whether to ask for additional fields or to recommend restaurant.

parse/train/ByquB-WC-/ByquB-WC-_content_list.json

@@ -0,0 +1,1337 @@
+[
+    {
+        "type": "text",
+        "text": "FINDING REMO (RELATED MEMORY OBJECT): A SIMPLE NEURAL ARCHITECTURE FOR TEXT BASED REASONING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            745,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            184,
+            195,
+            398,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            260,
+            544,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To solve the text-based question and answering task that requires relational reasoning, it is necessary to memorize a large amount of information and find out the question relevant information from the memory. Most approaches were based on external memory and four components proposed by Memory Network. The distinctive component among them was the way of finding the necessary information and it contributes to the performance. Recently, a simple but powerful neural network module for reasoning called Relation Network (RN) has been introduced. We analyzed RN from the view of Memory Network, and realized that its MLP component is able to reveal the complicate relation between question and object pair. Motivated from it, we introduce Relation Memory Network (RMN) which uses MLP to find out relevant information on Memory Network architecture. It shows new state-of-the-art results in jointly trained bAbI-10k story-based question answering tasks and bAbI dialog-based question answering tasks. ",
+        "bbox": [
+            233,
+            296,
+            764,
+            476
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            512,
+            334,
+            529
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural network has made an enormous progress on the two major challenges in artificial intelligence: seeing and reading. In both areas, embedding methods have served as the main vehicle to process and analyze text and image data for solving classification problems. As for the task of logical reasoning, however, more complex and careful handling of features is called for. A reasoning task requires the machine to answer a simple question upon the delivery of a series of sequential information. For example, imagine that the machine is given the following three sentences: “Mary got the milk there.”, “John moved to the bedroom.”, and “Mary traveled to the hallway.” Once prompted with the question, “Where is the milk?”, the machine then needs to sequentially focus on the two supporting sentences, “Mary got the milk there.” and “Mary traveled to the hallway.” in order to successfully determine that the milk is located in the hallway. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Inspired by this reasoning mechanism, J. Weston & Bordes (2015) has introduced the memory network (MemNN), which consists of an external memory and four components: input feature map $( I )$ , generalization $( G )$ , output feature map $( O )$ , and response $( R )$ . The external memory enables the model to deal with a knowledge base without loss of information. Input feature map embeds the incoming sentences. Generalization updates old memories given the new input and output feature map finds relevant information from the memory. Finally, response produces the final output. ",
+        "bbox": [
+            174,
+            694,
+            823,
+            777
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Based on the memory network architecture, neural network based models like end-to-end memory network (MemN2N) (Sukhbaatar et al., 2015), gated end-to-end memory network (GMemN2N) (Liu & Perez, 2017), dynamic memory network (DMN) (Kumar et al., 2016), and dynamic memory network ${ \\bf { \\tau } } + \\left( { \\bf { D M N } } + \\right)$ (Xiong et al., 2016) are proposed. Since strong reasoning ability depends on whether the model is able to sequentially catching the right supporting sentences that lead to the answer, the most important thing that discriminates those models is the way of constructing the output feature map. As the output feature map becomes more complex, it is able to learn patterns for more complicate relations. For example, MemN2N, which has the lowest performance among the four models, measures the relatedness between question and sentence by the inner product, while the best performing $\\mathrm { D M N } +$ uses inner product and absolute difference with two embedding matrices. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, a new architecture called Relation Network (RN) (Santoro et al., 2017) has been proposed as a general solution to relational reasoning. The design philosophy behind it is to directly capture the supporting relation between the sentences through the multi-layer perceptron (MLP). Despite its simplicity, RN achieves better performance than previous models without any catastrophic failure. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The interesting thing we found is that RN can also be interpreted in terms of MemNN. It is composed of $O$ and $R$ where each corresponds to MLP which focuses on the related pair and another MLP which infers the answer. RN does not need to have $G$ because it directly finds all the supporting sentences at once. In this point of view, the significant component would be MLP-based output feature map. As MLP is enough to recognize highly non-linear pattern, RN could find the proper relation better than previous models to answer the given question. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            251
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "However, as RN considers a pair at a time unlike MemNN, the number of relations that RN learns is $n ^ { 2 }$ when the number of input sentence is $n$ . When $n$ is small, the cost of learning relation is reduced by $n$ times compared to MemNN based models, which enables more data-efficient learning (Santoro et al., 2017). However, when $n$ increases, the performance becomes worse than the previous models. In this case, the pair-wise operation increases the number of non-related sentence pairs more than the related sentence pair, thereby confuses RN’s learning. Santoro et al. (2017) has suggested attention mechanisms as a solution to filter out unimportant relations; however, since it interrupts the reasoning operation, it may not be the most optimal solution to the problem. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            368
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our proposed model, “Relation Memory Network” (RMN), is able to find complex relation even when a lot of information is given. It uses MLP to find out relevant information with a new generalization which simply erase the information already used. In other words, RMN inherits RN’s MLP-based output feature map on Memory Network architecture. Experiments show its state-ofthe-art result on the text-based question answering tasks. ",
+        "bbox": [
+            173,
+            375,
+            823,
+            445
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATION MEMORY NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            465,
+            467,
+            482
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/7eb120fde291b9a161c8cd3ccc1faa79e9b5898e4acbbdd63cbcb76eaff370f1.jpg",
+        "image_caption": [
+            "Figure 1: Relation Memory Network "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            502,
+            823,
+            688
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Relation Memory Network (RMN) is composed of four components - embedding, attention, updating, and reasoning. It takes as the inputs a set of sentences $\\mathbf { x } _ { 1 } , \\mathbf { x } _ { 2 } , . . . , \\mathbf { x } _ { n }$ and its related question $\\mathbf { u }$ , and outputs an answer a. Each of the $\\mathbf { x } _ { i }$ , $\\mathbf { u }$ , and a is made up of one-hot representation of words, for example, $\\mathbf { x } _ { i } = \\left\\{ \\mathbf { x } _ { i 1 } , \\mathbf { x } _ { i 2 } , \\mathbf { x } _ { i 3 } , . . . , \\mathbf { x } _ { i n _ { i } } \\right\\}$ $( \\mathbf { x } _ { i j } \\in \\mathbb { R } ^ { V } , j = ( \\overset { \\cdot } { 1 , 2 } , . . . , n _ { i } ) , V = \\overset { \\cdot } $ vocabulary size, $n _ { i } =$ number of words in sentence $i$ ). ",
+        "bbox": [
+            174,
+            739,
+            825,
+            810
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 EMBEDDING COMPONENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            393,
+            842
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We first embed words in each $\\mathbf { x } _ { i } = \\{ \\mathbf { x } _ { i 1 } , \\mathbf { x } _ { i 2 } , \\mathbf { x } _ { i 3 } , . . . , \\mathbf { x } _ { i n _ { i } } \\}$ and $\\mathbf { u }$ to a continuous space multiplying an embedding matrix $A \\in \\mathbb { R } ^ { d \\times V }$ i. Then, the embedded sentence is stored and represented as a memory object $\\mathbf { m } _ { i }$ while question is represented as $\\mathbf { q }$ . Any of the following methods are available for embedding component: simple sum (equation 1), position encoding (J. Weston & Bordes, 2015) (equation 2), concatenation (equation 3), LSTM, and GRU. In case of LSTM or GRU, $\\mathbf { m } _ { i }$ is the ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "final hidden state of it. ",
+        "bbox": [
+            174,
+            103,
+            321,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f039eff2446a68b6f7d0bf41b54fc9c972fcbcdd578918fc07c8afca4525f3f4.jpg",
+        "text": "$$\n\\mathbf { m } _ { i } = \\sum _ { j } A \\mathbf { x } _ { i j }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            112,
+            552,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2406516d1467f3ffac196fdbc18f30306e38df0da9396bcd087077da12af0b6d.jpg",
+        "text": "$$\n\\mathbf { m } _ { i } = \\sum _ { j } l _ { j } \\cdot A \\mathbf { x } _ { i j } \\quad ( l _ { k j } = ( 1 - j / n _ { i } ) - ( k / d ) ( 1 - 2 j / n _ { i } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            151,
+            702,
+            185
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1dd7b042b5ecbbc78b7bacf82f2531e714d7a8d86f40670dd6f9b136a76f9d03.jpg",
+        "text": "$$\n\\mathbf { m } _ { i } = [ A \\mathbf { x } _ { i 1 } , A \\mathbf { x } _ { i 2 } , \\ldots , A \\mathbf { x } _ { i n _ { i } } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            191,
+            601,
+            208
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As the following attention component takes the concatenation of $\\mathbf { m } _ { i }$ and $\\mathbf { q }$ , it is not necessarily the case that sentence and question have the same dimensional embedding vectors unlike previous memory-augmented neural networks. ",
+        "bbox": [
+            174,
+            212,
+            823,
+            253
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 ATTENTION COMPONENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            271,
+            390,
+            285
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Attention component can be applied more than once depending on the problem; Figure 1 illustrates 2 hop version of RMN. We refer to the $i ^ { t h }$ embedded sentence on the $t ^ { \\mathit { \\hat { t } h } }$ hop as $\\mathbf { m } _ { i } ^ { \\bar { t } }$ . ",
+        "bbox": [
+            176,
+            296,
+            823,
+            324
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To constitute the attention component, we applied simple MLP represented as $g _ { \\theta } ^ { t }$ . It must be ended with 1 unit output layer to provide a scalar weight $\\boldsymbol { w } _ { i } ^ { t }$ , which leads to an attention weight $\\alpha _ { i } ^ { t }$ between 0 and 1. In the beginning, a vector concatenated with $\\mathbf { m } _ { i } ^ { 1 }$ and $\\mathbf { q }$ flows to the $g _ { \\theta } ^ { 1 }$ . From the result of $g _ { \\theta } ^ { 1 }$ , attention weight $\\alpha _ { i } ^ { 1 }$ is calculated using additional variable $\\beta ^ { 1 } \\ ( \\geq 1 )$ to control the intensity of attention, inspired by the way Neural Turing Machine (Graves et al., 2014) reads from the memory. Then we get the related memory object $\\mathbf { r } ^ { 1 }$ , a weighted sum of $\\alpha _ { i } ^ { 1 }$ and memory object $\\mathbf { m } _ { i } ^ { 1 }$ for all $i$ . If there exist more hops, $\\mathbf { r } ^ { 1 }$ is directly taken to the next hop and iterates over this process with the updated memory object $\\mathbf { m } _ { i } ^ { 2 }$ . All the procedures are rewritten as equation 4, 5, and 6: ",
+        "bbox": [
+            173,
+            330,
+            825,
+            443
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c9d79c16787220823b27f5fbb28aae17bf616b59dbb4ce5cde331b79ccbad884.jpg",
+        "text": "$$\n\\begin{array} { r l } { w _ { i } ^ { t }  g _ { \\theta } ^ { t } ( [ \\mathbf { m } _ { i } ^ { t } , \\mathbf { r } ^ { t - 1 } ] ) } & { { } ( i = ( 1 , 2 , . . . , n ) , ~ \\mathbf { r } ^ { 0 } = \\mathbf { q } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            449,
+            665,
+            468
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f82f7f569e02a225ea2a6018f3494355685aa495a7136a8a8bb5db9df99bd1f7.jpg",
+        "text": "$$\n\\alpha _ { i } ^ { t }  \\frac { \\exp ( \\beta ^ { t } w _ { i } ^ { t } ) } { \\sum _ { i } \\exp ( \\beta ^ { t } w _ { i } ^ { t } ) } \\quad ( \\beta ^ { t } ( z ) = 1 + \\log ( 1 + \\exp ( z ) ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            484,
+            683,
+            520
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/edf7a6f102c8f1d71155ddd48a41d5a6fe17998aa1834feb07c6cb9f9b493a58.jpg",
+        "text": "$$\n\\mathbf { r } ^ { t }  \\sum _ { i } { \\boldsymbol { \\alpha } _ { i } ^ { t } \\cdot \\mathbf { m } _ { i } ^ { t } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            439,
+            529,
+            558,
+            563
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 UPDATING COMPONENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            577,
+            380,
+            592
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To forget the information already used, we use intuitive updating component to renew the memory. It is replaced by the amount of unconsumed from the old one: ",
+        "bbox": [
+            171,
+            603,
+            821,
+            632
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e394effa12579af209559686215a2b10c00f56158893911b1b4cd91469e376cf.jpg",
+        "text": "$$\n\\mathbf { m } _ { i } ^ { t + 1 } \\gets ( 1 - \\alpha _ { i } ^ { t } ) \\mathbf { m } _ { i } ^ { t }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            636,
+            573,
+            655
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Contrary to other components, updating is not a mandatory component. When it is considered to have 1 hop, there is no need to use this. ",
+        "bbox": [
+            173,
+            661,
+            826,
+            689
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.4 REASONING COMPONENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            705,
+            392,
+            720
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Similar to attention component, reasoning component is also made up of MLP, represented as $f _ { \\phi }$ . It receives both q and the final result of attention component $\\mathbf { r } ^ { f }$ and then takes a softmax to produce the model answer aˆ: ",
+        "bbox": [
+            174,
+            732,
+            825,
+            775
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dc72e78dfe36f8e422297b3180fd4d5ec05d3d4d36125b7e9f864f0ee9acd3fa.jpg",
+        "text": "$$\n\\hat { \\mathbf { a } } \\gets \\mathrm { S o f t m a x } ( f _ { \\phi } ( [ \\mathbf { r } ^ { f } , \\mathbf { q } ] ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            772,
+            588,
+            792
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            810,
+            344,
+            827
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 MEMORY-AUGMENTED NEURAL NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            840,
+            514,
+            856
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To answer the question from a given set of facts, the model needs to memorize these facts from the past. Long short term memory (LSTM) (Hochreiter & Schmidhuber, 1997), one of the variants of recurrent neural network (RNN), is inept at remembering past stories because of their small internal memory (Sukhbaatar et al., 2015). To cope with this problem, J. Weston & Bordes (2015) has proposed a new class of memory-augmented model called Memory Network (MemNN). MemNN comprises an external memory $m$ and four components: input feature map $( I )$ , generalization $( G )$ , output feature map $( O )$ , and response $( R )$ . $I$ encodes the sentences which are stored in memory $m$ . $G$ updates the memory, whereas $O$ reads output feature $o$ from the memory. Finally, $R$ infers an answer from $o$ . ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/73607abdaf80c33625e050033196d188443b8ded20878336347fb3edb700c762.jpg",
+        "table_caption": [
+            "Table 1: MemN2N, RN, and RMN in terms of MemNN architecture "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Output feature map</td><td rowspan=1 colspan=1>Generalization</td></tr><tr><td rowspan=1 colspan=1>MemN2N</td><td rowspan=1 colspan=1>αt = Softmax(rt)Tmt)(r° = q)0t=∑amrt+1=ot+r²</td><td rowspan=1 colspan=1>mt = Wtmt-1</td></tr><tr><td rowspan=1 colspan=1>RN</td><td rowspan=1 colspan=1>ri = g0-MLP([mi,mj,q])0=∑iri</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>RMN</td><td rowspan=1 colspan=1>rt = g𝑠-MLP([m𝑡,rt-1])(r°=q)αt = Softmax(βtrt)rt=∑am</td><td rowspan=1 colspan=1>m²=(1-at-1)m+-1</td></tr></table>",
+        "bbox": [
+            240,
+            126,
+            758,
+            282
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            309,
+            825,
+            380
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "MemN2N, GMemN2N, DMN, and $\\mathrm { D M N } +$ all follow the same structure of MemNN from a broad perspective, however, output feature map is composed in slightly different way. The relation between question and supporting sentences is realized from its cooperation. MemN2N first calculates the relatedness of sentences in the question and memory by taking the inner product, and the sentence with the highest relatedness is selected as the first supporting sentence for the given question. The first supporting sentence is then added with the question and repeat the same operation with the updated memory to find the second supporting sentence. GMemN2N selects the supporting sentence in the same way as MemN2N, but uses the gate to selectively add the the question to control the influence of the question information in finding the supporting sentence in the next step. DMN and $\\mathrm { D M N } +$ use output feature map based on various relatedness such as absolute difference, as well as inner product, to understand the relation between sentence and question at various points. ",
+        "bbox": [
+            174,
+            386,
+            825,
+            539
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The more difficult the task, the more complex the output feature map and the generalization component to get the correct answer. For a dataset experimenting the text-based reasoning ability of the model, the overall accuracy could be increased in order of MemN2N, GMemN2N, DMN, and $\\mathrm { D M N } +$ , where the complexity of the component increases. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 RELATION NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            622,
+            362,
+            636
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Relation Network (RN) has emerged as a new and simpler framework for solving the general reasoning problem. RN takes in a pair of objects as its input and simply learns from the compositions of two MLPs represented as $g _ { \\boldsymbol { \\theta } }$ and $f _ { \\phi }$ . The role of each MLP is not clearly defined in the original paper, but from the view of MemNN, it can be understood that $g _ { \\theta }$ corresponds to $O$ and $f _ { \\phi }$ corresponds to $R$ . Table 1 summarizes the interpretation of RN compared to MemN2N and our model, RMN. ",
+        "bbox": [
+            173,
+            648,
+            825,
+            732
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To verify the role of $g _ { \\theta }$ , we compare the output when pairs are made with supporting sentences and when made with unrelated sentences. Figure 2 shows the visualization result of each output. When we focus on whether the value is activated or not, we can see that $g _ { \\theta }$ distinguishes supporting sentence pair from non-supporting sentence pair as output feature map examines how relevant the sentence is to the question. Therefore, we can comprehend the output of $g _ { \\theta }$ reveals the relation between the object pair and the question and $f _ { \\phi }$ aggregates all these outputs to infer the answer. ",
+        "bbox": [
+            173,
+            739,
+            825,
+            824
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/96576067658a24a913e1e947bf9e72e765bb3a9f087e37e9562f86f8289c928f.jpg",
+        "image_caption": [
+            "Figure 2: The output vector of $g _ { \\boldsymbol { \\theta } }$ when the input objects are related and unrelated "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            218,
+            849,
+            777,
+            895
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            326,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            157,
+            279,
+            171
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "bAbI story-based QA dataset bAbI story-based QA dataset (Weston et al., 2015) is composed of 20 different types of tasks for testing natural language reasoning ability. Each task requires different methods to infer the answer. The dataset includes a set of statements comprised of multiple sentences, a question and answer. A statement can be as short as two sentences and as long as 320 sentences. To answer the question, it is necessary to find relevant one or more sentences to a given question and derive answer from them. Answer is typically a single word but in a few tasks, answers are a set of words. Each task is regarded as success when the accuracy is greater than $9 5 \\%$ . There are two versions of this dataset, one that has 1k training examples and the other with 10k examples. Most of the previous models test their accuracy on 10k dataset with trained jointly. ",
+        "bbox": [
+            173,
+            199,
+            825,
+            324
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "bAbI dialog dataset bAbI dialog dataset (Bordes & Weston, 2016) is a set of 5 tasks within the goal-oriented context of restaurant reservation. It is designed to test if model can learn various abilities such as performing dialog management, querying knowledge bases (KBs), and interpreting the output of such queries. The KB can be queried using API calls and 4 fields (a type of cuisine, a location, a price range, and a party size). They should be filled to issue an API call. Task 1 tests the capacity of interpreting a request and asking the right questions to issue an API call. Task 2 checks the ability to modify an API call. Task 3 and 4 test the capacity of using outputs from an API call to propose options in the order of rating and to provide extra-information of what user asks for. Task 5 combines everything. The maximum length of the dialog for each task is different: 14 for task 1, 20 for task 2, 78 for task 3, 13 for task 4, and 96 for task 5. As restaurant name, locations, and cuisine types always face new entities, there are normal and OOV test sets to assess model’s generalization ability. Training sets consist fo 1k examples, which is not a large amount of creating realistic learning conditions. ",
+        "bbox": [
+            173,
+            332,
+            825,
+            512
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            569,
+            348,
+            583
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "bAbI story-based QA dataset We trained 2 hop RMN jointly on all tasks using 10k dataset for model to infer the solution suited to each type of tasks. We limited the input to the last 70 stories for all tasks except task 3 for which we limited input to the last 130 stories, similar to Xiong et al. (2016) which is the hardest condition among previous models. Then, we labeled each sentence with its relative position. Embedding component is similar to Santoro et al. (2017), where story and question are embedded through different LSTMs; 32 unit word-lookup embeddings; 32 unit LSTM for story and question. For attention component, as we use 2 hop RMN, there are $\\bar { g _ { \\theta } ^ { 1 } }$ and $g _ { \\theta } ^ { 2 }$ ; both are three-layer MLP consisting of 256, 128, 1 unit with ReLU activation function (Nair & Hinton, 2010). $f _ { \\phi }$ is composed of 512, 512, and 159 units (the number of words appearing in bAbI dataset is 159) of three-layer MLP with ReLU non-linearities where the final layer was a linear that produced logits for a softmax over the answer vocabulary. For regularization, we use batch normalization (Ioffe & Szegedy, 2015) for all MLPs. The softmax output was optimized with a cross-entropy loss function using the Adam optimizer (Kingma & Ba, 2014) with a learning rate of $2 e ^ { - 4 }$ . ",
+        "bbox": [
+            173,
+            611,
+            825,
+            791
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "bAbI dialog dataset We trained on full dialog scripts with every model response as answer, all previous dialog history as sentences to be memorized, and the last user utterance as question. Model selects the most probable response from 4,212 candidates which are ranked from a set of all bot utterances appearing in training, validation and test sets (plain and OOV) for all tasks combined. We also report results when we use match type features for dialog. Match type feature is an additional label on the candidates indicating if word is found on the dialog history. For example, if the world ‘Seoul’ is found, then the ‘location’ field is checked to hint model this word is important and should be used in API call. This feature can alleviate OOV problem. Training was done with Adam optimizer and a learning rate of $1 e ^ { - 4 }$ for all tasks. Additional model details are given in Appendix A. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/9af390ef4712edcb048208c05952a393bb0f5302e1f0c627b018aacbb5f8df4c.jpg",
+        "table_caption": [
+            "Table 2: Test error on bAbI story-based tasks with 10k training samples "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>MemNN</td><td>MemN2N</td><td>GMemN2N</td><td>DMN</td><td>DMN+</td><td>DNC</td><td>EntNet1</td><td>RN2</td><td>RMN</td></tr><tr><td>1: Single Supporting Fact</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.1</td><td>0.0</td><td>0.0</td></tr><tr><td>2: Two Supporting Facts</td><td>0.0</td><td>0.3</td><td>0.0</td><td>1.8</td><td>0.3</td><td>0.4</td><td>2.8</td><td>8.3</td><td>0.5</td></tr><tr><td>3: Three Supporting Facts</td><td>0.0</td><td>9.3</td><td>4.5</td><td>4.8</td><td>1.1</td><td>1.8</td><td>10.6</td><td>17.1</td><td>14.7</td></tr><tr><td>4: Two Argument Relations</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>5:Three Argument Relations</td><td>2.0</td><td>0.6</td><td>0.2</td><td>0.7</td><td>0.5</td><td>0.8</td><td>0.4</td><td>0.7</td><td>0.4</td></tr><tr><td>6:Yes/No Questions</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.3</td><td>0.0</td><td>0.0</td></tr><tr><td>7: Counting</td><td>15.0</td><td>3.7</td><td>1.8</td><td>3.1</td><td>2.4</td><td>0.6</td><td>0.8</td><td>0.4</td><td>0.5</td></tr><tr><td>8: Lists/Sets</td><td>9.0</td><td>0.8</td><td>0.3</td><td>3.5</td><td>0.0</td><td>0.3</td><td>0.1</td><td>0.3</td><td>0.3</td></tr><tr><td>9: Simple Negation</td><td>0.0</td><td>0.8</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.2</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>10: Indefinite Knowledge</td><td>2.0</td><td>2.4</td><td>0.2</td><td>2.5</td><td>0.0</td><td>0.2</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>11:Basic Coreference</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.1</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.4</td><td>0.5</td></tr><tr><td>12:Conjunction</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>13:Compound Coreference</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.2</td><td>0.0</td><td>0.1</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>14: Time Reasoning</td><td>1.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.4</td><td>3.6</td><td>0.0</td><td>0.0</td></tr><tr><td>15:Basic Deduction</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>16: Basic Induction</td><td>0.0</td><td>0.4</td><td>0.0</td><td>0.6</td><td>45.3</td><td>33.1</td><td>52.1</td><td>4.9</td><td>0.9</td></tr><tr><td>17: Positional Reasoning</td><td>35.0</td><td>40.7</td><td>27.8</td><td>40.4</td><td>4.2</td><td>12.0</td><td>11.7</td><td>1.6</td><td>0.3</td></tr><tr><td>18:Size Reasoning</td><td>5.0</td><td>6.7</td><td>8.5</td><td>4.7</td><td>2.1</td><td>0.8</td><td>2.1</td><td>2.1</td><td>2.3</td></tr><tr><td>19:Path Finding</td><td>64.0</td><td>66.5</td><td>31.0</td><td>65.5</td><td>0.0</td><td>3.9</td><td>63.0</td><td>3.2</td><td>2.9</td></tr><tr><td>20:Agent&#x27;s Motivations</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>Mean error (%)</td><td>6.7</td><td>6.6</td><td>3.7</td><td>6.4</td><td>2.8</td><td>2.7</td><td>7.4</td><td>2.0</td><td>1.2</td></tr><tr><td>Failed tasks (err. &gt;5%)</td><td>4</td><td>4</td><td>3</td><td>2</td><td>1</td><td>2</td><td>4</td><td>2</td><td>1</td></tr></table>",
+        "bbox": [
+            173,
+            127,
+            826,
+            381
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/d62f4fdfb3e860d1c184a3a001daae73e93fc505a51d9aa2054e4ce3d2dd8cf4.jpg",
+        "table_caption": [
+            "Table 3: bAbI story-based task visualization of $\\alpha$ ",
+            "(c) Task 3 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Seq.</td><td rowspan=1 colspan=1>Task3:Three Supporting Facts</td><td rowspan=1 colspan=1>α1</td><td rowspan=1 colspan=1>a²</td></tr><tr><td></td><td rowspan=8 colspan=1>Daniel took the football.Sandra travelled to the bedroom .Daniel moved to the bathroom.Sandra got the milk .Daniel travelled to the garden.Daniel went to the hallway .Daniel put down the apple .Daniel put down the football there .</td><td rowspan=1 colspan=1>0.46</td><td rowspan=1 colspan=1>0.01</td></tr><tr><td rowspan=1 colspan=1>39</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.00</td></tr><tr><td rowspan=6 colspan=1>404142465051</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.31</td></tr><tr><td rowspan=1 colspan=1>0.00</td><td rowspan=1 colspan=1>0.00</td></tr><tr><td rowspan=1 colspan=1>0.04</td><td rowspan=1 colspan=1>0.42</td></tr><tr><td rowspan=1 colspan=1>0.00</td><td rowspan=1 colspan=1>0.25</td></tr><tr><td rowspan=1 colspan=1>0.00</td><td rowspan=1 colspan=1>0.01</td></tr><tr><td rowspan=1 colspan=1>0.38</td><td rowspan=1 colspan=1>0.00</td></tr><tr><td rowspan=1 colspan=1>User input</td><td rowspan=1 colspan=3>Where was the football before the garden ?</td></tr><tr><td rowspan=1 colspan=1>Answer</td><td rowspan=1 colspan=3>Bathroom</td></tr><tr><td rowspan=1 colspan=1>Modelanswer</td><td rowspan=1 colspan=3>Bathroom                    [Correct]</td></tr><tr><td rowspan=1 colspan=1>Seq.</td><td rowspan=1 colspan=1>Task3:Three SupportingFacts</td><td rowspan=1 colspan=1>a</td><td rowspan=1 colspan=1>a2</td></tr><tr><td rowspan=6 colspan=1>1356111214</td><td rowspan=6 colspan=1>Mary got the football.Mary picked up the football.Mary moved to the office.Mary went to the hallway.Mary travelled to the garden .Mary travelled to the kitchen .Mary moved to the office .</td><td rowspan=1 colspan=1>0.26</td><td rowspan=1 colspan=1>0.00</td></tr><tr><td rowspan=1 colspan=1>0.39</td><td rowspan=1 colspan=1>0.00</td></tr><tr><td rowspan=1 colspan=1>0.00</td><td rowspan=1 colspan=1>0.05</td></tr><tr><td rowspan=1 colspan=1>0.00</td><td rowspan=1 colspan=1>0.21</td></tr><tr><td rowspan=1 colspan=1>0.00</td><td rowspan=1 colspan=1>0.29</td></tr><tr><td rowspan=1 colspan=1>0.00</td><td rowspan=1 colspan=1>0.25</td></tr><tr><td rowspan=2 colspan=1>1622</td><td rowspan=2 colspan=1>Mary went to the garden .Mary discarded the football there .</td><td rowspan=1 colspan=1>0.00</td><td rowspan=1 colspan=1>0.05</td></tr><tr><td rowspan=1 colspan=1>0.24</td><td rowspan=1 colspan=1>0.00</td></tr><tr><td rowspan=1 colspan=1>User input</td><td rowspan=1 colspan=3>Where was the football before the garden ?</td></tr><tr><td rowspan=1 colspan=1>Answer</td><td rowspan=1 colspan=3>Office</td></tr><tr><td rowspan=1 colspan=1>Model answer</td><td rowspan=1 colspan=3>Kitchen                    [Incorrect]</td></tr></table>",
+        "bbox": [
+            503,
+            440,
+            823,
+            667
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/7b55a62600c584a590b759d3d9da186d66931b6a8a1f4a597a7050b0b57b8097.jpg",
+        "table_caption": [
+            "(a) Task 7 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Seq.</td><td>Task 7:Counting</td><td>a1</td><td>α²</td></tr><tr><td>8</td><td>John grabbed the apple there.</td><td>0.02</td><td>0.00</td></tr><tr><td>9</td><td>John gave the apple to Mary.</td><td>0.08</td><td>0.16</td></tr><tr><td>10</td><td>Mary passed the apple to John .</td><td>0.17</td><td>0.24</td></tr><tr><td>11</td><td>Mary journeyed to the hallway .</td><td>0.00</td><td>0.01</td></tr><tr><td>13</td><td>Sandra went to the garden .</td><td>0.00</td><td>0.00</td></tr><tr><td>14</td><td>Mary went to the kitchen .</td><td>0.00</td><td>0.03</td></tr><tr><td>15</td><td>Mary picked up the football there .</td><td>0.29</td><td>0.24</td></tr><tr><td>16</td><td>Mary picked up the milk there .</td><td>0.27</td><td>0.32</td></tr><tr><td>User input</td><td colspan=\"3\">Howmany objectsisMarycarrying?</td></tr><tr><td>Answer</td><td colspan=\"3\">Two</td></tr><tr><td>Model answer</td><td>Two</td><td colspan=\"2\">[Correct]</td></tr></table>",
+        "bbox": [
+            174,
+            440,
+            486,
+            544
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/1ae1d71d075b4595f33b0d9b5db8d0c114a0d1913a7b0daf318412b2117fec3e.jpg",
+        "table_caption": [
+            "(b) Task 14 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Seq.</td><td>Task14:Timereasoning</td><td>a1</td><td>a²</td></tr><tr><td>1</td><td>Marywent back to the school yesterday.</td><td>0.00</td><td>0.01</td></tr><tr><td>2</td><td>Fred went to the school yesterday</td><td>0.00</td><td>0.00</td></tr><tr><td>3</td><td>Julie went back to the kitchen yesterday .</td><td>0.13</td><td>0.98</td></tr><tr><td>4</td><td>Fred journeyed to the kitchen this morning</td><td>0.00</td><td>0.00</td></tr><tr><td>5</td><td>This morning julie journeyed to the school .</td><td>0.66</td><td>0.02</td></tr><tr><td>6</td><td>This evening mary went back to the school .</td><td>0.01</td><td>0.00</td></tr><tr><td>7</td><td>This afternoon julie went to the bedroom .</td><td>0.06</td><td>0.00</td></tr><tr><td>User input</td><td>Wherewas Julie before theschool ?</td><td></td><td></td></tr><tr><td>Answer</td><td>Kitchen</td><td colspan=\"2\"></td></tr><tr><td>Model answer</td><td>Kitchen</td><td colspan=\"2\">[Correct]</td></tr></table>",
+        "bbox": [
+            174,
+            571,
+            486,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 RESULTS AND DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            695,
+            433,
+            712
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 BABI STORY-BASED QA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            727,
+            382,
+            742
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As we can see in table 2, RMN shows state-of-the-art result on bAbI story-based Question Answering dataset: $9 8 . 8 \\%$ accuracy where only a single task with no catastrophic failure. It succeeded on task 17, 18, 19 where MemN2N, GMemN2N, and DMN are failed to solve, and on task 16 which $\\mathrm { D M N } +$ , DNC, and EntNet scored high error rates. ",
+        "bbox": [
+            173,
+            752,
+            823,
+            809
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 3 shows how our model solved several tasks. RMN’s attention component $g _ { \\theta } ^ { 1 }$ and $g _ { \\theta } ^ { 2 }$ complement each other to identify the necessary facts to answer correctly. Sometimes both $g _ { \\theta } ^ { 1 }$ and $g _ { \\theta } ^ { 2 }$ concentrate on the same sentences which are all critical to answer the question, and sometimes $g _ { \\theta } ^ { 1 }$ finds a fact related to the given question and with this information $g _ { \\theta } ^ { 2 }$ chooses the key fact to answer. While trained jointly, RMN learns these different solutions for each task. For the task 3, the only failed task, attention component still functions well; it focuses sequentially on the supporting sentences. However, the reasoning component, $f _ { \\phi }$ , had difficulty catching the word ‘before’. We could easily figure out ‘before’ implies ‘just before’ the certain situation, whereas RMN confused its meaning. As shown in table 3c, our model found all previous locations before the garden. Still, it is remarkable that the simple MLP carried out all of these various roles. ",
+        "bbox": [
+            176,
+            815,
+            821,
+            858
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 BABI DIALOG ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            218,
+            312,
+            232
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/b17d7905ff58909687ce11975ae8bce490cdc0c8195dcc9ab8dacdbc927cf815.jpg",
+        "table_caption": [
+            "Table 4: Test error on bAbI dialog tasks 3 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Task</td><td colspan=\"4\">Plain</td><td colspan=\"4\">WithMatch</td></tr><tr><td>MemN2N</td><td>GMemN2N</td><td>RN4</td><td>RMN</td><td>MemN2N</td><td>GMemN2N</td><td>RN4</td><td>RMN</td></tr><tr><td>1: Issuing API calls</td><td>0.1</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>2: Updating API calls</td><td>0.0</td><td>0.0</td><td>0.5</td><td>0.0</td><td>1.7</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>3:Displaying options</td><td>25.1</td><td>25.1</td><td>26.6</td><td>25.1</td><td>25.1</td><td>25.1</td><td>27.1</td><td>25.1</td></tr><tr><td>4: Providing extra information</td><td>40.5</td><td>42.8</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>5: Conducting full dialogs</td><td>3.9</td><td>3.7</td><td>23.3</td><td>2.5</td><td>6.6</td><td>2.0</td><td>16.6</td><td>1.8</td></tr><tr><td>Average error rates(%)</td><td>13.9</td><td>14.3</td><td>10.1</td><td>5.5</td><td>6.7</td><td>5.4</td><td>8.7</td><td>5.4</td></tr><tr><td>1 (OOV): Issuing API calls</td><td>27.7</td><td>17.6</td><td>17.8</td><td>16.8</td><td>3.5</td><td>0.0</td><td>1.5</td><td>0.0</td></tr><tr><td>2 (OOV): Updatining API calls</td><td>21.1</td><td>21.1</td><td>23.2</td><td>21.1</td><td>5.5</td><td>5.8</td><td>0.0</td><td>0.0</td></tr><tr><td>3(OOV): Displaying options</td><td>25.6</td><td>24.7</td><td>27.2</td><td>24.9</td><td>24.8</td><td>24.9</td><td>29.8</td><td>25.1</td></tr><tr><td>4(OOV): Providing extra information</td><td>42.4</td><td>43.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td>5(OOV): Conducting full dialogs</td><td>34.5</td><td>33.3</td><td>38.3</td><td>34.5</td><td>22.3</td><td>20.6</td><td>28.4</td><td>21.7</td></tr><tr><td>Average error rates (%)</td><td>30.3</td><td>27.9</td><td>21.3</td><td>19.5</td><td>11.2</td><td>10.3</td><td>12.0</td><td>9.4</td></tr></table>",
+        "bbox": [
+            173,
+            275,
+            825,
+            429
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results in the Table 4 show that the RMN has the best results in any conditions. Without any match type, RN and RMN outperform previous memory-augmented models on both normal and OOV tasks. This is mainly attributed to the impressive result on task 4 which can be interpreted as an effect of MLP based output feature map. ",
+        "bbox": [
+            173,
+            445,
+            825,
+            502
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To solve task 4, it is critical to understand the relation between ‘phone number’ of user input and ‘r phone’ of previous dialog as shown in Table 8c. We assumed that inner product was not sufficient to capture their implicit similarity and performed an supporting experiment. We converted RMN’s attention component to inner product based attention, and the results revealed the error rate increased to $1 1 . 3 \\%$ . ",
+        "bbox": [
+            174,
+            508,
+            825,
+            578
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the task 3 and task 5 where the maximum length is especially longer than the others, RN performs worse than MemN2N, GMemN2N and RMN. The number of unnecessary object pairs created by the RN not only increases the processing time but also decreases the accuracy. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            627
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "With the match type feature, all models other than RMN have significantly improved their performance except for task 3 compared to the plain condition. RMN was helped by the match type only on the OOV tasks and this implies RMN is able to find relation in the With Match condition for the normal tasks. ",
+        "bbox": [
+            174,
+            633,
+            823,
+            689
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "When we look at the OOV tasks more precisely, RMN failed to perform well on the OOV task 1 and 2 even though $g _ { \\theta } ^ { 1 }$ properly focused on the related object as shown in Table 8a. We state that this originated from the fact that the number of keywords in task 1 and 2 is bigger than that in task 4. In task 1 and 2, all four keywords (cuisine, location, number and price) must be correctly aligned from the supporting sentence in order to make the correct API call which is harder than task 4. Consider the example in Table 8a and Table 8c. Supporting sentence of task 4 have one keyword out of three words, whereas supporting sentences of task 1 and 2 consist of four keywords (cuisine, location, number and price) out of sixteen words. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            808
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Different from other tasks, RMN yields the same error rate $2 5 . 1 \\%$ with MemN2N and GMemN2N on the task 3. The main goal of task 3 is to recommend restaurant from knowledge base in the order of rating. All failed cases are displaying restaurant where the user input is <silence>which is somewhat an ambiguous trigger to find the input relevant previous utterance. As shown in Table 8b, there are two different types of response to the same user input. One is to check whether all the required fields are given from the previous utterances and then ask user for the missing fields or send a “Ok let me look into some options for you.” message. The other type is to recommend restaurant starting from the highest rating. All models show lack of ability to discriminate these two types of silences so that concluded to the same results. To verify our statement, we performed an additional experiment on task 3 and checked the performance gain (extra result is given in Table 10 of Appendix B). ",
+        "bbox": [
+            174,
+            815,
+            825,
+            886
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 MODEL ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            204,
+            341,
+            219
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Effectiveness of the MLP-based output feature map The most important feature that distinguishes MemNN based models is the output feature map. Table 5 summarizes the experimental results for the bAbI story-based QA dataset when replacing the RMN’s MLP-based output feature map with the idea of the previous models. inner product was used in MemN2N, inner product with gate was used in GMemN2N, and inner product and absolute difference with two embedding matrices was used in DMN and $\\mathrm { D M N } +$ . From the Table 5, the more complex the output feature map, the better the overall performance. In this point of view, MLP is the effective output feature map. ",
+        "bbox": [
+            173,
+            229,
+            825,
+            329
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/ff2e9e9cf182357d95ff6d25527361671f92218ff104eb3a58e40e5b00b86492.jpg",
+        "table_caption": [
+            "Table 5: Test error of RMN on bAbI story-based QA dataset with different configurations "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>inner product</td><td rowspan=1 colspan=1> inner product with gate</td><td rowspan=1 colspan=1>inner product and absolute differencewith two embedding matrices</td><td rowspan=1 colspan=1>MLP</td></tr><tr><td rowspan=1 colspan=1>error rate</td><td rowspan=1 colspan=1>29.4</td><td rowspan=1 colspan=1>25.9</td><td rowspan=1 colspan=1>11.2</td><td rowspan=1 colspan=1>1.2</td></tr></table>",
+        "bbox": [
+            186,
+            367,
+            810,
+            409
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Performance of RN and RMN according to memory size Additional experiments were conducted with the bAbI story-based QA dataset to see how memory size affects both performance and training time of RN and RMN. Test errors with training time written in parentheses are summarized in Table 6. ",
+        "bbox": [
+            173,
+            422,
+            825,
+            478
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "When memory size is small, we could observe the data-effeciency of RN. It shows similar performance to RMN in less time. However, when the memory size increases, performance is significantly reduced compared to RMN, even though it has been learned for a longer time. It is even lower than itself when the memory size is 20. On the other hand, RMN maintains high performance even when the memory size increases. ",
+        "bbox": [
+            174,
+            486,
+            825,
+            556
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/2077baeeda4cf5c83613b9d9ab275de0f802aef2f8d45b2d82248721640398aa.jpg",
+        "table_caption": [
+            "Table 6: Test error and training time of RN and RMN on bAbI story-based QA dataset with different memory size "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>memory size</td><td rowspan=1 colspan=1>RN</td><td rowspan=1 colspan=1>RMN</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>2.0 (0.65 days)</td><td rowspan=1 colspan=1>1.5 (1.46 days)</td></tr><tr><td rowspan=1 colspan=1>130</td><td rowspan=1 colspan=1>9.8 (9.47 days)</td><td rowspan=1 colspan=1>1.2 (4.94 days)</td></tr></table>",
+        "bbox": [
+            326,
+            609,
+            669,
+            655
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Effectiveness of the number of hops bAbI story based QA dataset differs in the number of supporting sentences by each task that need to be referenced to solve problems. For example, task 1, 2, and 3 require single, two, and three supporting facts, respectively. The result of the mean error rate for each task according to the number of hops is in Table 7. ",
+        "bbox": [
+            174,
+            669,
+            825,
+            726
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Overall, the number of hops is correlated with the number of supporting sentences. In this respect, when the number of relations increases, RMN could reason across increasing the number of hops to 3, 4 or more. ",
+        "bbox": [
+            174,
+            732,
+            825,
+            773
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e42d0edc4d4beae892bfc67abb4f4bb44c7819f37018259755979fa9418e6ffd.jpg",
+        "table_caption": [
+            "Table 7: Test error of RMN on bAbI story-based QA dataset with different number of hops "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>hop 1</td><td rowspan=1 colspan=1>hop 2</td><td rowspan=1 colspan=1>hop 3</td></tr><tr><td rowspan=1 colspan=1>task 1 (1)</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>0.2</td></tr><tr><td rowspan=1 colspan=1>task 2 (2)</td><td rowspan=1 colspan=1>62.0</td><td rowspan=1 colspan=1>0.5</td><td rowspan=1 colspan=1>2.1</td></tr><tr><td rowspan=1 colspan=1>task 3 (3)</td><td rowspan=1 colspan=1>62.4</td><td rowspan=1 colspan=1>14.7</td><td rowspan=1 colspan=1>14.6</td></tr><tr><td rowspan=1 colspan=1>task 10 (1)</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>3.6</td></tr></table>",
+        "bbox": [
+            366,
+            823,
+            632,
+            898
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5Number in parentheses indicates the number of supporting sentences to solve the task ",
+        "bbox": [
+            194,
+            910,
+            707,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our work, RMN, is a simple and powerful architecture that effectively handles text-based question answering tasks when large size of memory and high reasoning ability is required. Multiple access to the external memory to find out necessary information through a multi-hop approach is similar to most existing approaches. However, by using a MLP that can effectively deal with complex relatedness when searching for the right supporting sentences among a lot of sentences, RMN raised the state-of-the-art performance on the story-based QA and goal-oriented dialog dataset. When comparing RN which also used MLP to understand relations, RMN was more effective in the case of large memory. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            244
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Future work will apply RMN to image based reasoning task (e.g., CLEVR, DAQUAR, VQA etc.). To extract features from the image, VGG net (Simonyan & Zisserman, 2014) is used in convention and outputs 196 objects of 512 dimensional vectors which also require large sized memory. An important direction will be to find an appropriate way to focus sequentially on related object which was rather easy in text-based reasoning. ",
+        "bbox": [
+            174,
+            252,
+            825,
+            321
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(a) Plain and OOV result of task 1 ",
+        "text_level": 1,
+        "bbox": [
+            398,
+            127,
+            599,
+            140
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/e973c2cc98ffb45bf9c1828bd7aaa4d3eaa5925d2e5d460bc2f89d529d0b557d.jpg",
+        "table_caption": [
+            "Table 8: Visualization of $\\alpha$ on bAbI dialog task 1, 3, and 4 without match type "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Seq.</td><td>Locutor</td><td>Task 1: Issuing API calls</td><td>a1</td></tr><tr><td>1 2</td><td>user</td><td>Good morning Hello what can i help you with today</td><td>0.01</td></tr><tr><td></td><td>bot</td><td></td><td>0.01</td></tr><tr><td>3</td><td>user</td><td>Can you make restaurant reservation for eight people in cheap price range with british cuisine</td><td>0.23</td></tr><tr><td>4</td><td>bot</td><td>I&#x27;m on it</td><td>0.00</td></tr><tr><td>5</td><td>user</td><td>&lt;silence&gt;</td><td>0.14</td></tr><tr><td>6</td><td>bot</td><td>Where should it be</td><td>0.01</td></tr><tr><td>7</td><td>user</td><td>In madrid</td><td>0.25</td></tr><tr><td>8</td><td>bot</td><td>Ok let me look into some options for you</td><td>0.18</td></tr><tr><td colspan=\"2\">User input</td><td>&lt;silence&gt;</td><td></td></tr><tr><td colspan=\"2\">Answer</td><td>API_call british madrid eight cheap</td><td></td></tr><tr><td colspan=\"2\">Modelanswer</td><td>API_call british madrid eight cheap [Correct]</td><td></td></tr><tr><td>Seq.</td><td>Locutor</td><td>Task1(OOV):IssuingAPIcalls</td><td>α1</td></tr><tr><td>1</td><td>user</td><td>Hi</td><td>0.01</td></tr><tr><td>2</td><td>bot</td><td>Hello what can i help you with today</td><td>0.01</td></tr><tr><td>3 4</td><td>user bot</td><td>May Ihave table with cantonese cuisine in cheap price range in seoul for two people</td><td>0.49</td></tr><tr><td>5</td><td>user</td><td>I&#x27;m on it &lt;silence&gt;</td><td>0.10</td></tr><tr><td>6</td><td>bot</td><td></td><td>0.01 0.27</td></tr><tr><td>User input</td><td></td><td>Ok let me look into some options for you</td><td></td></tr><tr><td colspan=\"2\">Answer</td><td>&lt;silence&gt; API_call cantonese seoul two cheap</td><td></td></tr><tr><td colspan=\"2\">Model answer</td><td>API_call italian paris two cheap</td><td></td></tr></table>",
+        "bbox": [
+            207,
+            147,
+            792,
+            371
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(b) Same user input with different goal in task 3 ",
+        "text_level": 1,
+        "bbox": [
+            359,
+            388,
+            640,
+            401
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/6dcc2c0460dfb37d793138ca85438581816f024c8e5fbb6e796807a473bbabbb.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Seq.</td><td>Locutor</td><td>Task 3:Displaying options</td><td>aT</td></tr><tr><td rowspan=\"5\">7 14 21 22 23</td><td rowspan=\"5\">user user user user bot</td><td>resto_l rrating1 resto_8 rrating 8</td><td rowspan=\"2\">0.01 0.01 0.01 0.01 0.01</td></tr><tr><td></td></tr><tr><td>resto.3 r_rating 3</td><td></td></tr><tr><td>Hello</td><td></td></tr><tr><td>Hello what can i help you with today Can you book table with french food for two people in madrid in moderate price range I&#x27;m on it</td><td>0.21</td></tr><tr><td colspan=\"2\">24 user 25 bot</td></tr><tr><td colspan=\"2\">User input &lt;silence&gt; Answer Where should it be?</td><td colspan=\"2\"></td></tr><tr><td colspan=\"2\">Model answer</td><td colspan=\"3\">Whereshould itbe? [Correct]</td></tr><tr><td>Seq.</td><td>Locutor</td><td>Task3:Displayingoptions</td><td>a1</td></tr><tr><td>7</td><td>user</td><td>resto_l rrating 1</td><td>0.00</td></tr><tr><td>14</td><td>user user</td><td>resto_8 rrating 8 resto_3 r_rating 3</td><td>0.00</td></tr><tr><td>24</td><td>user</td><td>Can you book table with french food for two people in madrid in moderate price range</td><td>0.00 0.14</td></tr><tr><td></td><td>bot</td><td></td><td></td></tr><tr><td>252627</td><td>user</td><td>I&#x27;m on it</td><td>0.00</td></tr><tr><td></td><td>bot</td><td>&lt;silence&gt;</td><td>0.09</td></tr><tr><td></td><td>user</td><td>Ok let me look into some options for you</td><td>0.15</td></tr><tr><td>28</td><td>bot</td><td>&lt;silence&gt;</td><td>0.10</td></tr><tr><td>29</td><td>user</td><td>What do you think of this option : resto_8</td><td>0.08</td></tr><tr><td>30</td><td>bot</td><td>No this does not work for me</td><td>0.06</td></tr><tr><td>31</td><td></td><td>Sure let me find other option for you</td><td>0.08</td></tr><tr><td colspan=\"2\">User input</td><td>&lt;silence&gt;</td><td></td></tr><tr><td colspan=\"2\">Answer</td><td>What do you think of this option: resto.3</td><td colspan=\"2\"></td></tr><tr><td colspan=\"2\">Modelanswer</td><td colspan=\"3\">Whatdo you think of thisoption:resto_7 [Incorrect]</td></tr></table>",
+        "bbox": [
+            207,
+            407,
+            790,
+            671
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(c) Plain and OOV result of task 4 ",
+        "text_level": 1,
+        "bbox": [
+            398,
+            689,
+            599,
+            702
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/eb2f7f8b6d80c3e71bd1736cd7f1ad5c23ff909dcecf80f0ab4d6d9a072d8b66.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Seq.</td><td>Locutor</td><td>Task4:Providingextrainformation</td><td>α1</td><td></td></tr><tr><td>1</td><td>user</td><td>resto_3r_phone resto_3_phone</td><td></td><td>0.77</td></tr><tr><td>3</td><td>user</td><td>resto_3 r_addressresto_3_address</td><td></td><td>0.01</td></tr><tr><td>4</td><td>user</td><td>resto_3 r_location london</td><td></td><td>0.01</td></tr><tr><td>6</td><td>user</td><td>resto.3 r-price cheap</td><td></td><td>0.01</td></tr><tr><td>10</td><td>user</td><td>I&#x27;d like to book table at resto_3</td><td></td><td>0.02</td></tr><tr><td>11</td><td>bot</td><td>Great let me do reservation</td><td></td><td>0.03</td></tr><tr><td colspan=\"2\">User input</td><td colspan=\"3\">Whatis phone number of restaurant?</td></tr><tr><td colspan=\"2\">Answer</td><td colspan=\"3\">Hereitis:resto_3_phone</td></tr><tr><td colspan=\"2\">Model answer</td><td colspan=\"3\">Here itis:resto_3_phone [Correct]</td></tr><tr><td>Seq.</td><td>Locutor</td><td>Task 4(OOV):Providingextra information</td><td></td><td>a1</td></tr><tr><td>1</td><td>user</td><td>resto_1 r-phone resto_l-phone</td><td></td><td>0.79</td></tr><tr><td>3</td><td>user</td><td>resto_1 r_address resto_1_address</td><td></td><td>0.01</td></tr><tr><td>4</td><td>user</td><td>resto_lr_location hanoi</td><td></td><td>0.01</td></tr><tr><td>6</td><td>user</td><td>resto_1 r_price expensive</td><td></td><td>0.01</td></tr><tr><td>10</td><td>user</td><td>Can you make restaurant reservation at resto_1</td><td></td><td>0.01</td></tr><tr><td>11</td><td>bot</td><td>Great let me do reservation</td><td></td><td>0.04</td></tr><tr><td colspan=\"2\">User input</td><td>Whatisphone number of restaurant?</td><td colspan=\"2\"></td></tr><tr><td colspan=\"2\">Answer</td><td>Here itis:resto_l_phone</td><td colspan=\"2\"></td></tr><tr><td colspan=\"2\">Model answer</td><td colspan=\"3\">Here it is:resto_1_phone [Correct]</td></tr></table>",
+        "bbox": [
+            205,
+            708,
+            792,
+            912
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Antoine Bordes and Jason Weston. Learning end-to-end goal-oriented dialog. CoRR, abs/1605.07683, 2016. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            155
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014. ",
+        "bbox": [
+            174,
+            162,
+            825,
+            193
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            200,
+            823,
+            231
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448– 456, 2015. ",
+        "bbox": [
+            173,
+            238,
+            823,
+            281
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "S. Chopra J. Weston and A. Bordes. Memory networks. International Conference on Learning Representations (ICLR), 2015. ",
+        "bbox": [
+            171,
+            290,
+            823,
+            319
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            328,
+            823,
+            357
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ankit Kumar, Ozan Irsoy, Peter Ondruska, Mohit Iyyer, James Bradbury, Ishaan Gulrajani, Victor Zhong, Romain Paulus, and Richard Socher. Ask me anything: Dynamic memory networks for natural language processing. In International Conference on Machine Learning, pp. 1378–1387, 2016. ",
+        "bbox": [
+            173,
+            366,
+            826,
+            421
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fei Liu and Julien Perez. Gated end-to-end memory networks. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 1, Long Papers, volume 1, pp. 1–10, 2017. ",
+        "bbox": [
+            176,
+            431,
+            823,
+            474
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th international conference on machine learning (ICML-10), pp. 807–814, 2010. ",
+        "bbox": [
+            174,
+            482,
+            823,
+            526
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Santoro, David Raposo, David GT Barrett, Mateusz Malinowski, Razvan Pascanu, Peter Battaglia, and Timothy Lillicrap. A simple neural network module for relational reasoning. Advances in neural information processing systems, 2017. ",
+        "bbox": [
+            174,
+            534,
+            823,
+            577
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. ",
+        "bbox": [
+            174,
+            585,
+            821,
+            616
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Jason Weston, Rob Fergus, et al. End-to-end memory networks. In Advances in neural information processing systems, pp. 2440–2448, 2015. ",
+        "bbox": [
+            173,
+            623,
+            821,
+            654
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jason Weston, Antoine Bordes, Sumit Chopra, and Tomas Mikolov. Towards ai-complete question answering: A set of prerequisite toy tasks. CoRR, abs/1502.05698, 2015. ",
+        "bbox": [
+            173,
+            661,
+            823,
+            691
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Caiming Xiong, Stephen Merity, and Richard Socher. Dynamic memory networks for visual and textual question answering. In International Conference on Machine Learning, pp. 2397–2406, 2016. ",
+        "bbox": [
+            174,
+            699,
+            823,
+            742
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A MODEL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            349,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/745c21c93b5c8f3430d34490da6e18f1c8f3b4ccb4472783958a58c8bcbe8eca.jpg",
+        "table_caption": [
+            "Table 9: Hyperparameters of Relation Memory Networks on bAbI dialog tasks "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Task</td><td rowspan=1 colspan=1>Story and QuestionEmbedding</td><td rowspan=1 colspan=1>Word-lookupEmbedding Dim</td><td rowspan=1 colspan=1>Hop</td><td rowspan=1 colspan=1>90</td><td rowspan=1 colspan=1>f</td><td rowspan=1 colspan=1>Activation</td><td rowspan=1 colspan=1>Use Batch Norm</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>sum</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2048,2048,1</td><td rowspan=1 colspan=1>2048,2048,4212</td><td rowspan=1 colspan=1>tanh</td><td rowspan=1 colspan=1>True</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>sum</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1024,1024,1</td><td rowspan=1 colspan=1>1024，1024,4212</td><td rowspan=1 colspan=1>tanh</td><td rowspan=1 colspan=1>True</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>sum</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1024，1024,1024，1</td><td rowspan=1 colspan=1>1024，1024，1024，4212</td><td rowspan=1 colspan=1>tanh</td><td rowspan=1 colspan=1>True</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>concatenation</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1024,1024,1</td><td rowspan=1 colspan=1>1024，1024,4212</td><td rowspan=1 colspan=1>tanh</td><td rowspan=1 colspan=1>True</td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>concatenation</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>4096,4096,1</td><td rowspan=1 colspan=1>4096,4096,4212</td><td rowspan=1 colspan=1>tanh</td><td rowspan=1 colspan=1>True</td></tr></table>",
+        "bbox": [
+            207,
+            164,
+            792,
+            229
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B ADDITIONAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            260,
+            400,
+            276
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 10: Visualization of $\\alpha ^ { 1 }$ and $\\alpha ^ { 2 }$ on user input revised bAbI dialog task 3 without match type ",
+        "bbox": [
+            178,
+            295,
+            816,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/becec2b97f280038dd58af50bcf17d7186ac0fb59c01cb2550e4990866950a80.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Seq.</td><td>Locutor</td><td>Task 3:Displaying options</td><td>α1</td><td>α²</td></tr><tr><td>1</td><td>user</td><td>resto_8 r_phone resto_8_phone</td><td>0.00</td><td>0.01</td></tr><tr><td></td><td>user</td><td>resto_8 r_cuisine french</td><td>0.01</td><td>0.01</td></tr><tr><td></td><td>user</td><td>resto_8 r_address resto_8_address</td><td>0.01</td><td>0.01</td></tr><tr><td></td><td>user</td><td>resto_8 r_location madrid</td><td>0.01</td><td>0.01</td></tr><tr><td>２３456</td><td>user</td><td>resto_8 r_number two</td><td>0.00</td><td>0.01</td></tr><tr><td></td><td>user</td><td>resto_8 r_price moderate</td><td>0.00</td><td>0.01</td></tr><tr><td>78</td><td>user</td><td>resto_8 r_rating 8</td><td>0.01</td><td>0.39</td></tr><tr><td></td><td>user</td><td>resto.3 r_phone resto-3_phone</td><td>0.01</td><td>0.01</td></tr><tr><td>9</td><td>user</td><td>resto.3 r_cuisine french</td><td>0.00</td><td>0.01</td></tr><tr><td>10</td><td>user</td><td>resto_3 r_address resto_3_address</td><td>0.00</td><td>0.01</td></tr><tr><td>11</td><td>user</td><td>resto_3 r_location madrid</td><td>0.00</td><td>0.01</td></tr><tr><td>12</td><td>user</td><td>resto.3 r_number two</td><td>0.00</td><td>0.01</td></tr><tr><td>13</td><td>user</td><td>resto_3 r_price moderate</td><td>0.00</td><td>0.01</td></tr><tr><td>14</td><td>user</td><td>resto_3 rrating 3</td><td>0.00</td><td>0.01</td></tr><tr><td>15</td><td>user</td><td>resto_l r_phone resto_l_phone</td><td>0.01</td><td>0.01</td></tr><tr><td>16</td><td>user</td><td>resto_l r_cuisine french</td><td>0.01</td><td>0.01</td></tr><tr><td>17</td><td>user</td><td>resto_l r_address resto_l_address</td><td>0.01</td><td>0.01</td></tr><tr><td>18</td><td>user</td><td>resto_1 r_location madrid</td><td>0.01</td><td>0.01</td></tr><tr><td>19</td><td>user</td><td>resto_1 r_number two</td><td>0.00</td><td>0.01</td></tr><tr><td></td><td>user</td><td>resto_l r-price moderate</td><td>0.00</td><td>0.01</td></tr><tr><td></td><td>user</td><td>resto_l rrating 1</td><td>0.00</td><td>0.01</td></tr><tr><td></td><td>user</td><td>Good morning</td><td>0.01</td><td>0.01</td></tr><tr><td></td><td>bot</td><td>Hello what can I help you with today?</td><td>0.12</td><td>0.01</td></tr><tr><td>202122324252627282930</td><td>user</td><td>May Ihave table for two with french food?</td><td>0.08</td><td>0.02</td></tr><tr><td></td><td>bot</td><td>I&#x27;m on it</td><td>0.03</td><td>0.01</td></tr><tr><td></td><td>user</td><td>&lt;silence&gt;</td><td>0.01</td><td>0.01</td></tr><tr><td></td><td>bot</td><td>Where should it be</td><td>0.09</td><td>0.01</td></tr><tr><td></td><td>user</td><td>In madrid</td><td>0.01</td><td>0.01</td></tr><tr><td></td><td>bot</td><td>Which price range are looking for?</td><td>0.09</td><td>0.01</td></tr><tr><td></td><td>user</td><td>In moderate price range please</td><td>0.01</td><td>0.01</td></tr><tr><td>31</td><td>bot</td><td>Ok let me look into some options for you</td><td>0.24</td><td>0.01</td></tr><tr><td colspan=\"2\">User input</td><td colspan=\"3\">&lt;silence&gt;&lt;silence&gt;</td></tr><tr><td colspan=\"2\">Answer</td><td colspan=\"3\">What do you think of this option: resto_8</td></tr><tr><td colspan=\"2\">Model answer</td><td colspan=\"3\">What do you think of this option: resto_8 [correct]</td></tr></table>",
+        "bbox": [
+            205,
+            323,
+            792,
+            695
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We modify the user input from $<$ silence $>$ to $<$ <silence> $<$ <silence $>$ when looking for restaurant recommendations. This makes model to distinguish two different situations whether to ask for additional fields or to recommend restaurant. ",
+        "bbox": [
+            174,
+            712,
+            823,
+            755
+        ],
+        "page_idx": 11
+    }
+]

parse/train/JOxB9h40A-1/JOxB9h40A-1.md

@@ -0,0 +1,474 @@
+# Model-Based Domain Generalization
+
+Alexander Robey George J. Pappas Hamed Hassani
+
+Department of Electrical and Systems Engineering University of Pennsylvania {arobey1,pappasg,hassani}@seas.upenn.edu
+
+# Abstract
+
+Despite remarkable success in a variety of applications, it is well-known that deep learning can fail catastrophically when presented with out-of-distribution data. Toward addressing this challenge, we consider the domain generalization problem, wherein predictors are trained using data drawn from a family of related training domains and then evaluated on a distinct and unseen test domain. We show that under a natural model of data generation and a concomitant invariance condition, the domain generalization problem is equivalent to an infinite-dimensional constrained statistical learning problem; this problem forms the basis of our approach, which we call Model-Based Domain Generalization. Due to the inherent challenges in solving constrained optimization problems in deep learning, we exploit nonconvex duality theory to develop unconstrained relaxations of this statistical problem with tight bounds on the duality gap. Based on this theoretical motivation, we propose a novel domain generalization algorithm with convergence guarantees. In our experiments, we report improvements of up to $30 \%$ over state-of-the-art domain generalization baselines on several benchmarks including ColoredMNIST, Camelyon17-WILDS, FMoW-WILDS, and PACS. Our code is publicly available at the following link: https://github.com/arobey1/mbdg.
+
+# 1 Introduction
+
+Despite well-documented success in numerous applications [1–4], the complex prediction rules learned by modern machine learning methods can fail catastrophically when presented with outof-distribution (OOD) data [5–9]. Indeed, rapidly growing bodies of work conclusively show that state-of-the-art methods are vulnerable to distributional shifts arising from spurious correlations [10–12], adversarial attacks [13–17], sub-populations [18–21], and naturally-occurring variation [22–24]. This failure mode is particularly pernicious in safety-critical applications, wherein the shifts that arise in fields such as medical imaging [25–28], autonomous driving [29–31], and robotics [32–34] are known to lead to unsafe behavior. And while some progress has been made toward addressing these vulnerabilities, the inability of modern machine learning methods to generalize to OOD data is one of the most significant barriers to deployment in safety-critical applications [35, 36].
+
+In the last decade, the domain generalization community has emerged in an effort to improve the OOD performance of machine learning methods [37–40]. In this field, predictors are trained on data drawn from a family of related training domains and then evaluated on a distinct and unseen test domain. Although a variety of approaches have been proposed for this setting [41, 42], it was recently shown that that no existing domain generalization algorithm can significantly outperform empirical risk minimization (ERM) $\bar { \lVert { 4 3 } \rVert }$ over the training domains when ERM is properly tuned and equipped with state-of-the-art architectures [44, 45] and data augmentation techniques $\dot { \left. \left[ 4 6 \right. \right. }$ . Therefore, due to the prevalence of OOD data in safety critical applications, it is of the utmost importance that new algorithms be proposed which can improve the OOD performance of machine learning methods.
+
+In this paper, we introduce a new framework for domain generalization which we call Model-Based Domain Generalization (MBDG). The key idea in our framework is to first learn transformations that map data between domains and then to subsequently enforce invariance to these transformations. Under a general model of covariate shift and a novel notion of invariance to learned transformations, we use this framework to rigorously re-formulate the domain generalization problem as a semi-infinite constrained optimization problem. We then use this re-formulation to prove that a tight approximation of the domain generalization problem can be obtained by solving the empirical, parameterized dual for this semi-infinite problem. Finally, motivated by these theoretical insights, we propose a new algorithm for domain generalization; extensive experimental evidence shows that our algorithm advances the state-of-the-art on a range of benchmarks by up to thirty percentage points.
+
+Contributions. Our contributions can be summarized as follows:
+
+• We propose a new framework for domain generalization in which invariance is enforced to underlying transformations of data which capture inter-domain variation. • Under a general model of covariate shift, we rigorously prove the equivalence of the domain generalization problem to a novel semi-infinite constrained statistical learning problem. We derive data-dependent duality gap bounds for the empirical parameterized dual of this semi-infinite problem, proving that tight approximations of the domain generalization problem can be obtained by solving this dual problem under the covariate shift assumption. • We introduce a primal-dual style algorithm for domain generalization in which invariance is enforced over unsupervised generative models trained on data from the training domains. • We empirically show that our algorithm significantly outperforms state-of-the-art baselines on several standard benchmarks, including ColoredMNIST, Camelyon17-WILDS, and PACS.
+
+# 2 Related work
+
+Domain generalization. The rapid acceleration of domain generalization research has led to an abundance of principled algorithms, many of which distill knowledge from an array of disparate fields toward resolving OOD failure modes [47–50]. Among such works, one prominent thrust has been to learn predictors which have internal feature representations that are consistent across domains [51– $\boxed { 6 2 } \mathbb { I }$ . This approach is also popular in the field of unsupervised domain adaptation [63–67], wherein it is assumed that unlabeled data from the test domain is available during training [68–70]. Also related are works that seek to learn a kernel-based embedding of each domain in an underlying feature space [71, $\boxed { 7 2 } \parallel$ , and those that employ Model-Agnostic Meta Learning $\mathbb { [   ]  }$ to adapt to unseen domains [42, 74–81]. Recently, another prominent direction has been to design weight-sharing [82–85] and instance re-weighting schemes [86–88]. Unlike any of these approaches, we explicitly enforce hard invariance-based constraints on the underlying statistical domain generalization problem.
+
+Data augmentation. Another approach to improve OOD performance is to augment the available training data. Among such methods, perhaps the most common is to leverage various forms of data augmentation $\pmb { \mathbb { B } } \pmb { \mathbb { \mathbb { Q } } } \pmb { \mathbb { Q } } \pmb { \mathbb { \Lambda } }$ . Recently, several approaches have used style-transfer techniques and imageto-image translation networks [97–104] to augment the training domains with artificially-generated data [105–112]. Alternatively, rather than generating new data, $\boxed { 1 } \boxed { 3 } \boxed { 1 } \boxed { 5 } $ all remove textural features in the data to encourage domain invariance. Unlike the majority of these works, we do not perform data augmentation directly on the training objective; rather, we derive a principled primal-dual style algorithm which enforces invariance constraints on data generated by unsupervised generative models.
+
+# 3 Domain generalization
+
+The domain generalization setting is characterized by a pair of random variables $( X , Y )$ over instances $x \in \mathcal { X } \subseteq \mathbb { R } ^ { d }$ and corresponding labels $y \in \mathcal { V }$ , where $( X , Y )$ is jointly distributed according to an unknown probability distribution $\mathbb { P } ( X , Y )$ . Ultimately, the objective in this setting is to learn a predictor $f$ such that $f ( X ) \ \approx \ Y$ , meaning that $f$ should be able to predict the labels $y$ of corresponding instances $x$ for each $( x , y ) \sim \mathbb { P } ( X , Y )$ . However, unlike in standard supervised learning tasks, the domain generalization problem is complicated by the assumption that one cannot sample directly from $\mathbb { P } ( X , Y )$ . Rather, it is assumed that we can only measure $( X , Y )$ under different environmental conditions, each of which corrupts or varies the data in a different way. For example, in medical imaging tasks, these environmental conditions might correspond to the imaging techniques and stain patterns used at different hospitals; this is illustrated in Figure 1a.
+
+To formalize this notion of environmental variation, we assume that data is drawn from a set of environments or domains ${ \mathcal { E } } _ { \mathrm { a l l } }$ (see Figure $^ { 1 \mathrm { b } ) }$ . Concretely, each domain $e \in \mathcal { E } _ { \mathrm { a l l } }$ can be identified with
+
+![](images/1b9fb81b4c0d6b44eb00ec8fe2bf4eaeb04daa52451e67a2ae8ebdb1f4dc198e.jpg)
+
+![](images/75802f2cf98e027ebb1f73c05310049540dd80f2482ba238daa7782a8dc5663c.jpg)
+
+(a) In domain generalization, the data are drawn from a family of related domains. For example, in the Camelyon17-WILDS dataset $\mathbb { \left. 2 0 \right. }$ , which contains images of cells, the domains correspond to different hospitals where these images were captured.
+
+(b) Each data point in a domain generalization task is observed in a particular domain $e \in \mathcal { E } _ { \mathrm { a l l } }$ . The set of all domains $\mathcal { E } _ { \mathrm { a l l } }$ can be thought of as an abstract space lying in $\mathbb { R } ^ { p }$ . In Camelyon17-WILDS, this space $\mathcal { E } _ { \mathrm { a l l } }$ corresponds to the set of all possible hospitals.
+
+(c) We assume that the variation from domain to domain is characterized by an underlying generative model $G ( x , e )$ , which transforms the unobserved random variable $X \mapsto G ( X , e ) : = X ^ { e }$ , where $X ^ { e }$ represents $X$ observed in any domain $e \in \mathcal { E } _ { \mathrm { a l l } }$ .
+
+Figure 1: An overview of the domain generalization problem setting used in this paper.
+
+a pair of random variables $( X ^ { e } , Y ^ { e } )$ , which together denote the observation of the random variable pair $( X , Y )$ in environment $e$ . Given samples from a finite subset $\mathcal { E } _ { \mathrm { t r a i n } } \subsetneq \mathcal { E } _ { \mathrm { a l l } }$ of domains, the goal of the domain generalization problem is to learn a predictor $f$ that generalizes across all possible environments, implying that ${ \bar { f ( X ) } } \approx Y$ . This can be summarized as follows:
+
+Problem 3.1 (Domain generalization). Let $\mathcal { E } _ { \mathrm { t r a i n } } \subsetneq \mathcal { E } _ { \mathrm { a l l } }$ be a finite subset of training domains, and assume that for each $e \in \mathcal { E } _ { \mathrm { t r a i n } }$ , we have access to a dataset $\mathcal { D } ^ { e } : = \{ ( x _ { j } ^ { e } , y _ { j } ^ { e } ) \} _ { j = 1 } ^ { n _ { e } }$ sampled i.i.d. from $\mathbb { P } ( X ^ { e } , Y ^ { e } )$ . Given a function class $\mathcal { F }$ and a loss function $\ell : \mathcal { V } \times \mathcal { V } \to \mathbb { R } _ { \geq 0 }$ , our goal is to learn a predictor $f \in { \mathcal { F } }$ using the data from the datasets $\mathcal { D } ^ { e }$ that minimizes the worst-case risk over the entire family of domains ${ \mathcal { E } } _ { \mathrm { a l l } }$ . That is, we want to solve the following optimization problem:
+
+$$
+{ \underset { f \in { \mathcal { F } } } { \mathrm { m i n i m i z e ~ } } } \ { \underset { e \in { \mathcal { E } } _ { \mathrm { a l l } } } { \mathrm { m a x } } } \ { \mathbb { E } } _ { \mathbb { P } ( X ^ { e } , Y ^ { e } ) } \ell ( f ( X ^ { e } ) , Y ^ { e } ) .
+$$
+
+In essence, in Problem $\boxed { 3 . 1 }$ we seek a predictor $f \in { \mathcal { F } }$ that generalizes from the finite set of training domains ${ \mathcal { E } } _ { \operatorname* { t r a i n } }$ to perform well on the set of all domains ${ \mathcal { E } } _ { \mathrm { a l l } }$ . However, note that while the inner maximization in $( \bar { \mathbf { D } } \mathbf { G } )$ is over the set of all training domains ${ \mathcal { E } } _ { \mathrm { a l l } }$ , by assumption we do not have access to data from any of the domains $e \in \mathcal { E } _ { \mathrm { a l l } } \backslash \mathcal { E } _ { \mathrm { t r a i n } }$ , making this problem challenging to solve. Indeed, as generalizing to arbitrary test domains is impossible $\mathbb { I m }$ , further structure is often assumed on the topology of ${ \mathcal { E } } _ { \mathrm { a l l } }$ and on the corresponding distributions $\mathbb { P } ( X ^ { e } , Y ^ { e } )$ .
+
+Disentangling the sources of variation across environments. The difficulty of a particular domain generalization task can be characterized by the extent to which the distribution of data in the unseen test domains $\mathcal { E } _ { \mathrm { a l l } } \backslash \mathcal { E } _ { \mathrm { t r a i n } }$ resembles the distribution of data in the training domains ${ \mathcal { E } } _ { \operatorname* { t r a i n } }$ . For instance, if the domains are assumed to be convex combinations of the training domains, as is often the case in multi-source domain generalization [117–119], Problem $\underline { { \lvert 3 . 1 \rvert } }$ can be seen as an instance of distributionally robust optimization $\mathbb { \ m }$ . More generally, in a similar spirit to $\mathbb { I } 1 1 6 ]$ , we identify two forms of variation across domains: covariate shift and concept shift. These shifts characterize the extent to which the marginal distributions over instances $\mathbb { P } ( X ^ { e } )$ and the instance-conditional distributions $\mathbb { P } ( Y ^ { e } | X ^ { e } )$ differ between domains. We capture these shifts in the following definition:
+
+Definition 3.2 (Covariate shift & concept shift). Problem $\boxed { 3 . 1 }$ is said to experience covariate shift if environmental variation is due to differences between the set of marginal distributions over instances $\{ \mathbb { P } ( X ^ { e } ) \} _ { e \in { \mathcal E } _ { \mathrm { a l l } } }$ . On the other hand, Problem $\boxed { 3 . 1 }$ is said to experience concept shift if environmental { } 2Eall variation is due to changes amongst the instance-conditional distributions $\{ \mathbb { P } ( Y ^ { e } | X ^ { e } ) \} _ { e \in { \mathcal E } _ { \mathrm { a l l } } }$ .
+
+The growing domain generalization literature encompasses a great deal of past work, wherein both of these shifts have been studied in various contexts $\pm \pm \pm \pm 2 5 ]$ . Indeed, as this literature has grown, new benchmarks have been developed which span the gamut between covariate and concept shift $\mathbb { \lVert 1 2 6 \rVert }$ . However, a large-scale empirical study recently showed that no existing algorithm can significantly outperform ERM across these standard domain generalization benchmarks when ERM is carefully implemented [46]. As ERM is known to fail in the presence natural distribution shifts $\mathbb { L } 2 \beth \mathbb { I }$ , this result highlights the critical need for new algorithms that can go beyond ERM toward solving Problem 3.1.
+
+# 4 Model-based domain generalization
+
+In what follows, we introduce a new framework for domain generalization that we call Model-Based Domain Generalization (MBDG). In particular, we prove that when Problem $\underline { { \boldsymbol { \mathsf { B . 1 } } } }$ is characterized solely by covariate shift, then under a natural invariance-based condition, Problem $3 . 1$ is equivalent to an infinite-dimensional constrained statistical learning problem, which forms the basis of MBDG.
+
+Formal assumptions for MBDG. In general, domain generalization tasks can be characterized by both covariate and concept shift. However, in this paper, we restrict the scope of our theoretical analysis to focus on problems in which inter-domain variation is due solely to covariate shift through an underlying model of data generation. Formally, we assume that the data in each domain $e \in \mathcal { E } _ { \mathrm { a l l } }$ is generated from the underlying random variable pair $( X , Y )$ via an unknown function $G$ .
+
+Assumption 4.1. Let $\delta _ { e }$ denote a Dirac distribution for $e \in \mathcal { E } _ { \mathrm { a l l } }$ . We assume that there exists1 a measurable function $G : \mathcal { X } \times \mathcal { E } _ { \mathrm { a l l } } \to \mathcal { X }$ , which we refer to as a domain transformation model, that parameterizes the inter-domain covariate shift via $\mathbb { P } ( X ^ { e } ) = ^ { d } G \# \left( \mathbb { P } ( X ) \times \dot { \delta } _ { e } \right) \forall e \in \mathcal { E } _ { \mathrm { a l l } }$ , where $\#$ denotes the push-forward measure and $= ^ { d }$ denotes equality in distribution.
+
+Informally, this assumption specifies that there should exist a function $G$ that relates the random variables $X$ and $X ^ { e }$ via $X \mapsto G ( X , e ) = X ^ { e }$ . In past work, this particular setting in which the instances $X ^ { e }$ measured in an environment $e$ are related to the underlying random variable $X$ has been referred to as domain shift [128, $\ S 1 . 8 ]$ . In our medical imaging example, the domain shift captured by a domain transformation model would characterize the mapping from the underlying distribution $\mathbb { P } ( X )$ over different cells to the distribution $\mathbb { P } ( X ^ { e } )$ of images of these cells observed at a particular hospital; this is illustrated in Figure $\boxed { \mathrm { l c } }$ wherein inter-domain variation is due to varying colors and stain patterns encountered at different hospitals. On the other hand, in this example example, the label $y \sim Y$ describing whether a given cell contains a cancerous tumor should not depend on the lighting and stain patterns used at different hospitals. In this sense, while in other applications, e.g. the datasets introduced in $\mathbb { \ m }$ , the instance-conditional distributions can vary across domains, in this paper we assume that inter-domain variation is solely characterized by the domain shift due to $G$ .
+
+Assumption 4.2 (Domain shift). We assume that inter-domain variation is solely characterized by domain shift in the marginal distributions $\mathbb { P } ( X ^ { e } )$ , as described in Assumption $\boxed { 4 . 1 }$ As a consequence, we assume that the instance-conditional distributions $\mathbb { P } ( Y ^ { e } | X ^ { e } )$ are stable across domains, meaning that $Y ^ { e }$ and $Y$ are equivalent in distribution and that for each $x \in \mathcal { X }$ and $y \in \mathcal { V }$ , it holds that
+
+$$
+\mathbb { P } ( Y = y | X = x ) = \mathbb { P } ( Y ^ { e } = y | X ^ { e } = G ( x , e ) ) \quad \forall e \in \mathcal { E } _ { \mathrm { a l l } } .
+$$
+
+Pulling back Problem $\underline { { \vert \mathbf { 3 . 1 } \vert } }$ The structure imposed on Problem $\boxed { 3 . 1 }$ by Assumptions $4 . 1$ and 4.2 provides a concrete way of parameterizing large families of distributional shifts in domain generalization problems. Indeed, the utility of these assumptions is that when taken together, they provide the basis for pulling-back Problem $\underline { { \dot { \left. 3 . 1 \right. } } }$ onto the underlying distribution $\mathbb { P } ( X , Y )$ via the domain transformation model $G$ . This insight is captured in the following proposition:
+
+Proposition 4.3. Under Assumptions 4.1 and 4.2, Problem $3 . 1$ is equivalent to
+
+$$
+\operatorname* { m i n i m i z e } _ { f \in { \mathcal { F } } } \operatorname* { m a x } _ { e \in { \mathcal { E } } _ { \mathrm { a l l } } } \mathbb { E } _ { \mathbb { P } ( X , Y ) } \ell ( f ( G ( X , e ) ) , Y ) .
+$$
+
+The proof of this fact is a straightforward consequence of the decomposition $\mathbb { P } ( X ^ { e } , Y ^ { e } ) = \mathbb { P } ( Y ^ { e } | X ^ { e } )$ · $\mathbb { P } ( X ^ { e } )$ in conjunction with Assumptions $\boxed { 4 . 1 }$ and $\boxed { 4 . 2 }$ (see Appendix $\boxed { C . 2 }$ . Note that this result allows us to implicitly absorb each of the domain distributions $\mathbb { P } ( \bar { X } ^ { e } , Y ^ { e } )$ into the domain transformation model. Thus, the outer expectation in $( 2 )$ is defined over the underlying distribution $\mathbb { P } ( X , Y )$ . On the other hand, just as in $( \mathrm { D } \bar { \mathrm { G } } )$ , this problem is still a challenging statistical min-max problem. To this end, we next introduce a new notion of invariance with respect to domain transformation models, which allows us to reformulate the problem in $( 2 )$ as a semi-infinite constrained optimization problem.
+
+A new notion of model-based invariance. Common to much of the domain generalization literature is the idea that predictors should be invariant to inter-domain changes. For instance, in $\mathbb { \lVert 1 0 \rVert }$ the authors seek to learn an equipredictive representation $\Phi : \mathcal { X }  \mathcal { Z }$ [129], i.e. an intermediate representation that satisfies $\mathbb { P } ( Y ^ { e _ { 1 } } | \Phi ( X ^ { e _ { 1 } } ) ) = \mathbb { P } ( Y ^ { e _ { 2 } } | \Phi ( X ^ { e _ { 2 } } ) ) \quad \forall e _ { 1 } , e _ { 2 } \in \mathcal { E } _ { \mathrm { a l l } }$ . Despite compelling theoretical motivation for this approach, it has been shown that current algorithms which seek equipredictive representations do not significantly improve over ERM $\pm \sqrt { 1 3 0 } \mp \overline { { 1 1 3 3 } } \rceil$ . With this in mind and given the additional structure introduced in Assumptions $4 . 1$ and $4 . 2 ,$ we introduce a new definition of invariance with respect to the variation captured by the underlying domain transformation model $G$
+
+Definition 4.4 ( $G$ -invariance). Given a domain transformation model $G$ , we say a classifier $f$ is G-invariant if it holds for all $e \in \mathcal { E } _ { \mathrm { a l l } }$ that $f ( x ) = f ( G ( x , e ) )$ almost surely when $x \sim \mathbb { P } ( X )$ .
+
+Concretely, this definition says that a predictor $f$ is $G$ -invariant if environmental changes under $G ( x , e )$ cannot change the prediction returned by $f$ . Intuitively, this notion of invariance couples with the definition of domain shift, in the sense that we expect that a prediction should return the same prediction for any realization of data under $G$ . Thus, whereas equipredictive representations are designed to enforce invariance of in an intermediate representation space $\mathcal { Z }$ , Definition $\boxed { 4 . 4 }$ is designed to enforce invariance directly on the predictions made by $f$ . In this way, in the setting of Figure $^ 1$ , $G$ -invariance would imply that the predictor $f$ would return the same label for a given cluster of cells regardless of the hospital at which these cells were imaged.
+
+Formulating the MBDG optimization problem. The $G$ -invariance property described in the previous section is the key toward reformulating the min-max problem in $\overset { \cdot } { ( 2 ) }$ . Indeed, the following proposition follows from Assumptions $^ { 4 . 1 }$ and 4.2 and from the definition of $G$ -invariance.
+
+Proposition 4.5. Under Assumptions $\boxed { 4 . 1 }$ and $\boxed { 4 . 2 }$ if we restrict the domain $\mathcal { F }$ of Problem $\boxed { 3 . 1 }$ to the set of $G$ -invariant predictors, then Problem $\boxed { 3 . 1 }$ is equivalent to the following constrained problem:
+
+<table><tr><td>P* ≌ minimize R(f)=EP(x,y) l(f(X),Y) fEF subject to f(x)= f(G(𝑥,e)) a.e. x ~P(X) ∀e ∈εall:</td></tr></table>
+
+Here a.e. stands for “almost everywhere” and $R ( f )$ is the statistical risk of a predictor $f$ with respect to the underlying random variable pair $( X , Y )$ . Note that unlike $( 2 )$ , $( \mathbf { M B D G } )$ is not a composite optimization problem, meaning that the inner maximization has been eliminated. In essence, the proof of Proposition $4 . 6$ relies on the fact that $G$ -invariance implies that predictions should not change across domains (see Appendix ${ \bf C } . 2 )$ . The optimization problem in $( \mathrm { M B D G } )$ forms the basis of our Model-Based Domain Generalization framework. To explicitly contrast this problem to Problem $3 . 1 ,$ we introduce the following concrete problem formulation for Model-Based Domain Generalization.
+
+Problem 4.6 (Model-Based Domain Generalization). As in Problem $3 . 1 ,$ let $\mathcal { E } _ { \mathrm { t r a i n } } \subsetneq \mathcal { E } _ { \mathrm { a l l } }$ be a finite subset of training domains and assume that we have access to datasets $\mathcal { D } ^ { e } \forall e \in \mathcal { E } _ { \mathrm { t r a i n } }$ . Then under Assumptions $\boxed { 4 . 1 }$ and $4 . 2 ,$ the goal of Model-Based Domain Generalization is to use the data from the training datasets to solve the semi-infinite constrained optimization problem in $( \mathbf { M B D G } )$
+
+Problem $4 . 6$ offers a principled perspective on Problem $3 . 1$ when data varies WRT an underlying domain transformation model. However, just as solving the min-max problem of Problem $\underline  { \dot { \left. \right\} 3 . 1 } }$ is known to be difficult, the problem in $\widetilde { ( | \mathbf { M B D G } ) }$ is also challenging to solve for several reasons:
+
+(C1) The $G$ -invariance constraint in $( \mathbf { M B D G } )$ is strict and thus challenging to enforce.   
+(C2) Problem $4 . 6$ is a constrained problem over an infinite-dimensional functional space $\mathcal { F }$ .   
+(C3) We do have access to the set of all domains ${ \mathcal { E } } _ { \mathrm { a l l } }$ or to the underlying distribution $\mathbb { P } ( X , Y )$ .   
+(C4) We also generally do not have access to the underlying domain transformation model $G$ .
+
+In the ensuing sections, we explicitly address each of these challenges toward developing a tractable method for approximately solving Problem $\boxed { 4 . 6 }$ with guarantees on optimality. In particular, we discuss challenges (C1), (C2), and (C3) in Section $\triangledown$ We then discuss (C4) in Section F.
+
+# 5 Data-dependent duality gap for MBDG
+
+In this section, we offer a principled analysis of Problem $\boxed { 4 . 6 }$ In particular, we first address (C1) by introducing a tight relaxation of the $G$ -invariance constraint. Next, to resolve the fundamental difficulty involved in solving constrained statistical problems highlighted in (C2), we formulate the parameterized dual problem, which is unconstrained and thus more suitable for learning with deep neural networks. Finally, to address (C3), we introduce an empirical version of the parameterized dual problem and explicitly characterize the data-dependent duality gap between this problem and Problem $4 . 6 .$ At a high level, this analysis results in an unconstrained optimization problem which is guaranteed to produce a solution that is close to the solution of Problem $3 . 1$ (see Theorem $\underline { { \left. 5 . 3 \right. } }$ In this section, we have chosen to present our results somewhat informally by deferring preliminary results, regularity assumptions, and proofs to the appendices.
+
+Addressing (C1) by relaxing the $G$ -invariance constraint. One of the most fundamental challenges in solving Problem $\mathsf { \bar { 4 . 6 } }$ is the difficulty of enforcing the $G$ -invariance equality constraint. To alleviate some of this difficulty, we introduce the following relaxation of Problem 4.6:
+
+$$
+P ^ { \star } ( \gamma ) \triangleq \operatorname* { m i n i m i z e } _ { f \in \mathcal { F } } R ( f ) \quad \mathrm { s . t . } \quad \mathcal { L } ^ { e } ( f ) \triangleq \mathbb { E } _ { \mathbb { F } ( X ) } d \big ( f ( X ) , f ( G ( X , e ) ) \big ) \leq \gamma \quad \forall e \in \mathcal { E } _ { \mathrm { a l } }
+$$
+
+where $\gamma > 0$ is a fixed margin the controls the extent to which we enforce $G$ -invariance and $d : \mathcal { P } ( \mathcal { V } ) \times \mathcal { P } ( \mathcal { V } ) \to \mathbb { R } _ { \geq 0 }$ is a distance metric over the space of probability distributions on $\mathcal { V }$ . While at first glance this problem may appear to be a significant relaxation of the MBDG optimization problem in $\mathrm { \ @ B D G ) }$ , when $\gamma = 0$ and under mild conditions on $d$ , the two problems are equivalent in the sense that $\overline { { P ^ { \star } ( 0 ) } } = P ^ { \star }$ (see Proposition $\boxed { \overline { { \mathbf { B } . 1 } } ) }$ . Indeed, we note that the conditions we require on $d$ are not restrictive, and include the KL-divergence and more generally the family of $f$ -divergences. Moreover, when the margin $\gamma$ is strictly larger than zero, under the assumption that the perturbation function $P ^ { \star } ( \gamma )$ is $L$ -Lipschitz continuous, we show in Remark $\overline { { \mathbb { B } . 2 } }$ that $| P ^ { \star } - P ^ { \star } ( \gamma ) | \leq \bar { L } \gamma$ , meaning that the gap between the problems is relatively small when $\gamma$ is chosen to be small. In particular, when strong duality holds for $ { \mathbb { M B D G } } )$ , this Lipschitz constant $L$ is equal to the $L ^ { 1 }$ norm of the optimal dual variable for $\mathrm { ( \overline { { M B D G } } ) }$ (see Remark $\underline { { \overline { { \mathbf { B . 4 } } } } } )$ .
+
+Addressing (C2) by formulating the parameterized dual problem. As written, the relaxation in $( 3 )$ is an infinite-dimensional constrained optimization problem over a functional space $\mathcal { F }$ (e.g. $L ^ { 2 }$ or the space of continuous functions). Optimization in this infinite-dimensional function space is not tractable, and thus we follow the standard convention by leveraging a finite-dimensional parameterization of $\mathcal { F }$ , such as the class of deep neural networks [134, 135]. The approximation power of such a parameterization can be captured in the following definition:
+
+Definition 5.1 $\epsilon$ -parameterization). Let $\mathcal { H } \subseteq \mathbb { R } ^ { p }$ be a finite-dimensional parameter space. For $\epsilon > 0$ , a function $\varphi : \mathcal { H } \times \mathcal { X } \to \mathcal { Y }$ is said to be an $\epsilon$ -parameterization of $\mathcal { F }$ if it holds that for each $f \in { \mathcal { F } }$ , there exists a parameter $\theta \in \mathcal H$ such that $\mathbb { E } _ { \mathbb { P } ( X ) } \bar { \lVert } \varphi ( \theta , x ) - f ( x ) \rVert _ { \infty } \leq \epsilon$ .
+
+The benefit of using such a parameterization is that optimization is generally more tractable in the parameterized space $\mathcal { A } _ { \epsilon } : = \bar { \{ \varphi ( \theta , \cdot ) : \theta \in \mathcal { H } \} } \subseteq \mathcal { F }$ . However, typical parameterizations often lead to nonconvex problems, wherein methods such as SGD cannot guarantee constraint satisfaction. And while several heuristic algorithms have been designed to enforce constraints over common parametric classes [136–141], these approaches cannot provide guarantees on the underlying statistical problem of interest [142]. Thus, to provide guarantees on the underlying statistical problem in Problem $4 . 6 ,$ given an $\epsilon$ -parameterization $\varphi$ of $\mathcal { F }$ , we consider the following saddle-point problem:
+
+$$
+D _ { \epsilon } ^ { \star } ( \gamma ) \triangleq \operatorname* { m a x i m i z e } _ { \lambda \in \mathcal { P } ( \mathcal { E } _ { \mathrm { a l l } } ) } \operatorname* { m i n } _ { \theta \in \mathcal { H } } R ( \theta ) + \int _ { \mathcal { E } _ { \mathrm { a l l } } } \left[ \mathcal { L } ^ { e } ( \theta ) - \gamma \right] \mathrm { d } \lambda ( e ) .
+$$
+
+where $\mathcal { P } ( \mathcal { E } _ { \mathrm { a l l } } )$ is the space of normalized probability distributions over ${ \mathcal { E } } _ { \mathrm { a l l } }$ and $\lambda \in \mathcal { P } ( \mathcal { E } _ { \mathrm { a l l } } )$ is the (semi-infinite) dual variable. Here we have slightly abused notation to write $R ( \theta ) = R ( \varphi ( \theta , \cdot ) )$ and $\mathcal { L } ^ { e } ( \theta ) = \mathcal { L } ^ { e } ( \varphi ( \theta , \cdot ) )$ . One can think of $\textcircled{4}$ as the dual problem to $( 3 )$ solved over the parametric space $\mathcal { A } _ { \epsilon }$ . Notice that unlike Problem $4 . 6 ,$ the problem in $\textcircled{4}$ is unconstrained, making it much more amenable for optimization over the class of deep neural networks. Moreover, under mild conditions, the optimality gap between $\textcircled{3}$ and $\textcircled{4}$ can be explicitly bounded as follows:
+
+Proposition 5.2 (Parameterization gap). Let $\gamma > 0$ be given. Under mild regularity assumptions (see Assumption C.1 in Appendix C.3) on $\ell$ and $d$ , there exists a small universal constant $k$ such that
+
+$$
+\begin{array} { r } { P ^ { \star } ( \gamma ) \leq D _ { \epsilon } ^ { \star } ( \gamma ) \leq P ^ { \star } ( \gamma ) + \epsilon k \left( 1 + \left\| \lambda _ { \mathtt { p e r t } } ^ { \star } \right\| _ { L ^ { 1 } } \right) , } \end{array}
+$$
+
+where $\lambda _ { \mathrm { p e r t } } ^ { \star }$ is the optimal dual variable for a perturbed version of $\textcircled{3}$ in which the constraints are tightened to hold with margin $\gamma - k \epsilon$ .
+
+Algorithm 1 Model-Based Domain Generalization (MBDG)   
+
+<table><tr><td>1:</td><td colspan="3">Hyperparameters: Primal step size ηp &gt; O, dual step size ηd ≥ O,margin γ &gt; 0</td></tr><tr><td>2: repeat</td><td colspan="3"></td></tr><tr><td>3:</td><td>for minibatch {(xj, yj)}m=1 in training dataset do</td><td></td><td></td></tr><tr><td>4:</td><td>𝑥j←GENERATEIMAGE(𝑥j)∀j∈[m]</td><td></td><td>Generate model-based images</td></tr><tr><td>5:</td><td>distReg(0)←(1/m)∑=1d((0,xj),(0,xj))</td><td></td><td> Calculate distance regularizer</td></tr><tr><td>6:</td><td>loss(0)←(1/m)∑=1e(xj,yj;(0,))</td><td></td><td> Calculate classification loss</td></tr><tr><td>7:</td><td> ←θ-npVθ[loss(0)+λ·distReg(0)]</td><td></td><td>Primal step for 0</td></tr><tr><td>8:</td><td>λ ←[+na (distReg(θ)-γ)]+</td><td></td><td>Dual step for 入</td></tr><tr><td>9:</td><td>end for</td><td></td><td></td></tr><tr><td>10:</td><td>until convergence</td><td></td><td></td></tr><tr><td>11:</td><td></td><td></td><td></td></tr><tr><td>12:</td><td>procedure GENERATEIMAGE(x)</td><td></td><td></td></tr><tr><td>13:</td><td>Sample e ~ N(0, I)</td><td>e is a latent code for MUNIT</td><td></td></tr><tr><td>14:</td><td>return G(x, e)</td><td>&gt;Return image produced by MUNIT</td><td></td></tr><tr><td>15:</td><td>end procedure</td><td></td><td></td></tr></table>
+
+In this way, solving the parameterized dual problem in $\textcircled{4}$ provides a solution that can be used to recover a close approximation of the primal problem in $\textcircled { \scriptsize { 1 3 } }$ . To see this, observe that Prop. $\underline { { \vert 5 . 2 \vert } }$ implies that $| D _ { \epsilon } ^ { \star } ( \gamma ) - \bar { P ^ { \star } } ( \gamma ) | \leq \epsilon k ( 1 + | | \lambda _ { \mathrm { p e r t } } ^ { \bar { \star } } | | _ { L ^ { 1 } } ) ^ { - }$ . This tells us that the gap between $P ^ { \star } ( \gamma )$ and $D _ { \epsilon } ^ { \star } ( \bar { \gamma } )$ is small when we use a tight $\epsilon$ -parameterization of $\mathcal { F }$ .
+
+Addressing (C3) by bounding the empirical duality gap. The parameterized dual problem in $( 4 )$ gives us a principled way to address Problem $4 . 6$ in the context of deep learning. However, complicating matters is the fact that we do not have access to the full distribution $\mathbb { P } ( X , Y )$ or to data from any of the domains in $\mathcal { E } _ { \mathrm { a l l } } \backslash \mathcal { E } _ { \mathrm { t r a i n } }$ . In practice, it is ubiquitous to solve optimization problems such as $( 4 )$ over a finite sample of $N$ data points drawn from $\mathbb { P } ( X , Y ) \big \sqcup$ More specifically, given $\{ ( x _ { j } , y _ { j } ) \} _ { j = 1 } ^ { N }$ drawn i.i.d. according to $( X , Y )$ , we consider the empirical counterpart of $\textcircled{4}$ :
+
+$$
+D _ { \epsilon , N , \mathcal { E } _ { \mathrm { m i n } } } ^ { \star } ( \gamma ) \triangleq \operatorname* { m a x i m i z e } _ { \lambda ( e ) \geq 0 , e \in \mathcal { E } _ { \mathrm { t r a i n } } } \operatorname* { m i n } _ { \theta \in \mathcal { H } } \hat { \Lambda } ( \theta , \lambda ) \triangleq \hat { R } ( \theta ) + \frac { 1 } { | \mathcal { E } _ { \mathrm { t r a i n } } | } \sum _ { e \in \mathcal { E } _ { \mathrm { t r a i n } } } \left[ \hat { \mathcal { L } } ^ { e } ( \theta ) - \gamma \right] \lambda ( e )
+$$
+
+where $\hat { R } ( \theta )$ and $\hat { \mathcal { L } } ^ { e } ( \theta )$ are the empirical counterparts of $R ( f )$ and $\mathcal L ( f )$ . Notably, the duality gap between the solution to $( 6 )$ and $\mathrm { \overline { { ( M B D G ) } } }$ can be explicitly bounded as follows.
+
+Theorem 5.3 (Data-dependent duality gap). Let $\epsilon > 0$ be given, and let $\varphi$ be an $\epsilon$ -parameterization of $\mathcal { F }$ . Under mild regularity assumptions on $\ell$ and $d$ and assuming that $\mathcal { A } _ { \epsilon }$ has finite VC-dimension, with probability $1 - \delta$ over the $N$ samples from $\mathbb { P } ( X , Y )$ we have that
+
+$$
+\begin{array} { r } { | P ^ { \star } - D _ { \epsilon , N , \mathcal { E } _ { \mathrm { r e i n } } } ^ { \star } ( \gamma ) | \leq L \gamma + \epsilon k \left( 1 + \big \| \lambda _ { \mathtt { p e r t } } ^ { \star } \big \| _ { L ^ { 1 } } \right) + \mathcal { O } \left( \sqrt { \log ( N ) / N } \right) } \end{array}
+$$
+
+where $L$ is the Lipschitz constant of $P ^ { \star } ( \gamma )$ and $k$ and $\lambda _ { \mathrm { p e r t } } ^ { \star }$ are as defined in Proposition 5.2.
+
+The key message to take away from Theorem $\textstyle \left\lceil 5 . 3 \right\rceil$ is that given samples from $\mathbb { P } ( X , Y )$ , the duality gap incurred by solving the empirical problem in $( 6 )$ is small when (a) the $G$ -invariance margin $\gamma$ is small, (b) the parametric space $\mathcal { A } _ { \epsilon }$ is a close approximation of $\mathcal { F }$ , and (c) we have access to sufficiently many samples. Thus, assuming that Assumptions $^ { 4 . 1 }$ and $\boxed { 4 . 2 }$ hold, the solution to Problem $\underline { { \boldsymbol { \mathsf { B . 1 } } } }$ is closely-approximated by the solution to the empirical, parameterized dual problem in $\textcircled{6}$ .
+
+# 6 MBDG: A principled algorithm for domain generalization
+
+Motivated by these theoretical insights, we now introduce a new domain generalization algorithm which is widely applicable to problems with or without covariate shift. Our algorithm consists of two steps. First, we learn an approximation of the underlying domain transformation model $G ( x , e )$ using the data from the training domains ${ \mathcal { E } } _ { \mathrm { t r a i n } }$ . Next, we leverage $G$ toward solving the unconstrained dual optimization problem in $( 6 )$ via a primal-dual iteration.
+
+Learning domain transformation models from data. Regarding challenge (C4), critical to our approach is having access to the domain transformation model $G$ . For the vast majority of settings, the underlying function $G ( x , e )$ is not known a priori and cannot be represented by a simple expression. For example, obtaining a closed-form expression for a model that captures the variation in coloration, brightness, and contrast in the dataset shown in Figure $^ 1$ would be very challenging. While in general it is impossible to learn the true underlying domain transformation model when one only has access to data from the training domains, we argue that a realistic approximation of the underlying model can be learned from this data. To this end, to learn a domain transformation model, we train multimodal image-to-image translation networks on the training data. These networks are designed to transform samples from one dataset so that they resemble a diverse collection of images from another dataset. In particular, in each of the experiments in Section $\textcircled { 7 }$ we use the MUNIT architecture introduced in $\lVert \overline { { 1 0 2 } } \rVert$ to parameterize learned domain transformation models. As shown in Figure 5 and in Appendix G, models trained using the MUNIT architecture learn accurate and diverse transformations of the training data, which often generalize to generate images from new domains.
+
+Primal-dual iteration. Given a learned approximation $G ( x , e )$ of the underlying domain transformation model, the next step in our procedure is to use a primal-dual iteration $\mathbb { \lVert 1 4 3 \rVert }$ toward solving $\textcircled{6}$ using the datasets $\mathcal { D } ^ { e }$ . We note that while our theory calls for data drawn from $\mathbb { P } ( X , Y )$ , the $G$ -invariance condition implies that when $\textcircled{6}$ is feasible, $\varphi ( \theta , x ) \approx \varphi ( \theta , x ^ { e } )$ when $x \sim \mathbb { P } ( X )$ , $x ^ { e } \sim \mathbb { P } ^ { e } ( X )$ , and $x ^ { e } = G ( x , e )$ . Therefore, the data from $\cup _ { e \in \mathcal { E } _ { \mathrm { u r a i n } } } \mathcal { D } ^ { e }$ is a useful proxy for data drawn from $\mathbb { P } ( X , Y )$ . As the outer maximization in $( 6 )$ is a linear program in $\lambda$ , the primal-dual iteration can be characterized by alternating between the following steps:
+
+$$
+\theta ^ { ( t + 1 ) } \in \rho \circ \operatorname * { a r g m i n } _ { \theta \in \mathcal { H } } \hat { \Lambda } ( \theta , \lambda ^ { ( t ) } ) \qquad ( 8 ) \qquad \lambda ^ { ( t + 1 ) } ( e )  [ \lambda ^ { ( t ) } ( e ) + \eta ( \hat { \mathcal { L } } ^ { e } ( \theta ) - \gamma ) ] _ { + }
+$$
+
+Here $[ \cdot ] _ { + } = \operatorname* { m a x } \{ 0 , \cdot \}$ , $\eta$ is the dual step size, and $\rho$ - argmin denotes a solution that is $\rho$ -close to being a minimizer, i.e. we should that have $\begin{array} { r } { \hat { \Lambda } \big ( \theta ^ { ( t + \mathrm { i } ) } , \lambda ^ { ( \vec { t } ) } \big ) \le \operatorname* { m i n } _ { \theta \in \mathcal { H } } \hat { \Lambda } \big ( \theta , \lambda ^ { ( t ) } \big ) + \rho } \end{array}$ . We call $( 8 )$ the primal step, and we call $( 9 )$ the dual step. Furthermore, it can be shown that if this iteration is run for sufficiently many steps and with small enough step size, the iteration convergences with high probability to a solution which closely approximates the solution to Problem 4.6.
+
+Theorem 6.1 (Primal-dual convergence). Assuming that $\ell$ and $d$ are $[ 0 , B ]$ -bounded, $\mathcal { H }$ has finite VC-dimension, and under mild regularity conditions on $\textcircled{6}$ , the primal-dual pair $( \theta ^ { ( T ) } , \lambda ^ { ( T ) } )$ obtained after running the alternating primal-dual iteration in $\textcircled { 8 }$ and $\mathring { ( 9 ) }$ for $T$ steps with step size $\eta$ , where
+
+$$
+T = \left\lceil { \frac { 1 } { 2 \eta \kappa } } \right\rceil + 1 \qquad { \mathrm { a n d ~ } } \qquad \eta \leq { \frac { 2 \kappa } { | { \mathcal { E } } _ { \mathrm { t r a i n } } | B ^ { 2 } } }
+$$
+
+satisfies $| P ^ { \star } - \hat { \Lambda } ( \theta ^ { ( T ) } , \mu ^ { ( T ) } ) | \leq K \underline { { ( \rho , \kappa , \epsilon ) } } + { \mathcal O } ( \sqrt { \log ( N ) / N } )$ . Here $\kappa$ is a constant that captures the regularity of $\textcircled{6}$ (see Appendix C.6) and $K ( \rho , { \dot { \kappa } } , \epsilon )$ is a small constant depending on $\rho , \kappa$ , and $\epsilon$
+
+This means that by solving the empirical dual problem for sufficiently many steps, we can reach a solution that is close to solving the Model-Based Domain Generalization problem in Problem $4 . 6 .$
+
+Implementation of MBDG. In practice, because (a) it may not be tractable to find a $\rho$ -minimizer over $\mathcal { H }$ at each iteration and (b) there may be a large number of domains in ${ \mathcal { E } } _ { \operatorname* { t r a i n } }$ , we propose two modifications of the primal-dual iteration in which we replace $\textcircled{8}$ with a stochastic gradient step and we use only one dual variable for all of the domains; we call this algorithm MBDG (see Algorithm 1). We provide results in Appendix $\boxed { \mathrm { E } }$ where one dual variable is used per training domain.
+
+# 7 Experiments
+
+We now evaluate the performance of MBDG on a range of standard domain generalization benchmarks. In the main text, we present results on ColoredMNIST, Camelyon17-WILDS, FMoW-WILDS, and PACS; we defer results on VLCS to the supplemental. For ColoredMNIST, PACS, and VLCS, we use the DomainBed package $\mathbb { H }$ , facilitating comparison to a range of baselines. Model selection for each of these datasets was performed using hold-one-out cross-validation. For Camelyon17-WILDS and FMoW-WILDS, we use the repository provided with the WILDS dataset suite, and we perform model-selection using the out-of-distribution validation set provided in the WILDS repository. Further details concerning hyperparameter tuning and model selection are deferred to Appendix E.
+
+Table 1: ColoredMNIST. We report accuracies for ColoredMNIST. Model-selection was performed via cross-validation.   
+
+<table><tr><td>Algorithm</td><td>+90%</td><td>+80%</td><td>-90%</td><td>Avg</td></tr><tr><td>ERM</td><td>50.0±0.2</td><td>50.1 ± 0.2</td><td>10.0 ± 0.0</td><td>36.7</td></tr><tr><td>IRM</td><td>46.7 ± 2.4</td><td>51.2 ± 0.3</td><td>23.1 ±10.7</td><td>40.3</td></tr><tr><td>GroupDRO</td><td>50.1 ± 0.5</td><td>50.0± 0.5</td><td>10.2 ± 0.1</td><td>36.8</td></tr><tr><td>Mixup</td><td>36.6 ± 10.9</td><td>53.4 ±5.9</td><td>10.2 ± 0.1</td><td>33.4</td></tr><tr><td>MLDG</td><td>50.1 ± 0.6</td><td>50.1 ± 0.3</td><td>10.0 ± 0.1</td><td>36.7</td></tr><tr><td>CORAL</td><td>49.5 ± 0.0</td><td>59.5 ±8.2</td><td>10.2 ± 0.1</td><td>39.7</td></tr><tr><td>MMD</td><td>50.3 ± 0.2</td><td>50.0± 0.4</td><td>9.9 ±0.2</td><td>36.8</td></tr><tr><td>DANN</td><td>49.9 ± 0.1</td><td>62.1 ± 7.0</td><td>10.0 ± 0.1</td><td>40.7</td></tr><tr><td>CDANN</td><td>63.2 ±10.1</td><td>44.4 ± 4.5</td><td>9.9 ±0.2</td><td>39.1</td></tr><tr><td>MTL</td><td>44.3 ± 4.9</td><td>50.7 ± 0.0</td><td>10.1 ± 0.1</td><td>35.0</td></tr><tr><td>SagNet</td><td>49.9 ± 0.4</td><td>49.7 ± 0.3</td><td>10.0 ± 0.1</td><td>36.5</td></tr><tr><td>ARM</td><td>50.0± 0.3</td><td>50.1 ± 0.3</td><td>10.2 ± 0.0</td><td>36.8</td></tr><tr><td>VREx</td><td>50.2 ±0.4</td><td>50.5 ± 0.5</td><td>10.1 ± 0.0</td><td>36.9</td></tr><tr><td>RSC</td><td>49.6 ± 0.3</td><td>49.7 ± 0.4</td><td>10.1 ± 0.0</td><td>36.5</td></tr><tr><td>MBDA</td><td>72.0 ± 0.1</td><td>50.7 ± 0.1</td><td>22.5 ± 0.0</td><td>48.3</td></tr><tr><td>MBDG-DA</td><td>72.7 ± 0.2</td><td>71.4 ± 0.1</td><td>33.2 ± 0.1</td><td>59.0</td></tr><tr><td>MBDG-Reg</td><td>73.3 ± 0.0</td><td>73.7 ± 0.0</td><td>27.2 ± 0.1</td><td>58.1</td></tr><tr><td>MBDG</td><td>73.7 ± 0.1</td><td>68.4 ± 0.0</td><td>63.5± 0.0</td><td>68.5</td></tr></table>
+
+![](images/29b59d0db22dd967d04e6a4120313eafe3ea7e54168c3393c0d68464607d7f67.jpg)  
+Figure 2: Tracking dual variables. We show the values of distReg $( \theta )$ and the dual variables $\lambda$ for the each MBDG models in Table $^ { 1 . }$ The margin $\gamma = 0 . 0 2 5$ is shown in red.
+
+# 7.1 ColoredMNIST
+
+We first consider the ColoredMNIST dataset $\mathbb { \ m }$ , which is a standard domain generalization benchmark created by colorizing subsets of the MNIST dataset $\mathbb { \lVert 1 4 4 \rVert }$ . This dataset contains three domains, each of which is characterized by a different level of correlation between the label and digit color. As shown in Table $\Pi ,$ the MBDG algorithm improves over each baseline by nearly ${ \overline { { 3 } } } 0 \%$ . To understand the reasons behind this improvement, we consider three ablation studies on ColoredMNIST.
+
+Tracking the dual variables. For the three MBDG classifiers in Table $\checkmark$ we plot the regularization term distReg $( \theta )$ and the corresponding dual variable at each training step in Figure $\boxed { 2 }$ Observe that for the $+ 9 0 \%$ and $+ 8 0 \%$ domains, the dual variables decay to zero, as the constraint is satisfied early on in training.
+
+![](images/c03fb35438f137d00670982fb289b9e0d979d018f44fbc7691a6b1edf4739766.jpg)  
+Figure 3: Regularized MBDG. We show the regularization value for each domain in ColoredMNIST for a fixed dual variable $\lambda = 1 . 0$ .
+
+On the other hand, the constraint for the $- 9 0 \%$ domain is not satisfied early on in training, and in response, the dual variable increases, gradually forcing constraint satisfaction. As we shown in the next subsection, without the dual update step, the constraints may never be satisfied (see Figure 3).
+
+Regularization vs. dual ascent. A common trick for encouraging constraint satisfaction is to introduce soft constraints by adding a regularizer multiplied by a fixed multiplier to the objective. While this approach yields a related problem to $\textcircled{6}$ (see Appendix $\underline { { \overline { { | \mathbf { B . 4 } } } ) } }$ where the dual variables are fixed, there are few formal guarantees for this approach. Moreover, we show in Table $\bigstar$ that when the dual variable is fixed during training (MBDG-Reg in Table $^ { 1 ) }$ , the performance drops significantly vis-a-vis MBDG. Notice that relative to Figure $\bar { 2 , }$ the value of distReg $\mathbf { \eta } ^ { ( \theta ) }$ is much larger than the margin, meaning that the constraint is not being satisfied.
+
+Ablation on data augmentation. To study the efficacy of the MBDG algorithm, we consider two natural alternatives MBDG: (1) ERM with data augmentation through the learned model $G ( x , e )$ (MBDA); and (2) MBDG with data augmentation through $G ( x , e )$ on the training objective (MBDGDA). As shown at the bottom of Table ${ \bf { \bar { \Phi } } } _ { 1 , \quad }$ while these variants significantly outperform the baselines, they not perform nearly as well as MBDG. Thus, while data augmentation can in some cases improve performance, the primal-dual iteration is a much more effective tool for enforcing invariance.
+
+# 7.2 Camelyon17-WILDS and FMoW-WILDS
+
+We next consider the Camelyon17-WILDS and FMoW-WILDS datasets from the WILDS family of domain generalization baselines $\pmb { \mathbb { D } } \pmb { \mathbb { O } } \|$ . Table $\bigstar$ shows that on Camelyon17-WILDS, MBDG improves by more than 20 percentage points over the state-of-the-art baselines.
+
+![](images/d3d2fc9dcbdba53376cc3763e969959b3fdd15b424c6e568b2e5f49fa2414dec.jpg)  
+Figure 4: Known vs. learned models ${ \bf G } ( { \bf x } , { \bf e } )$ . We compare the performance of MBDG for known models (first five columns) against a model that was trained with the data from the training domains using MUNIT.
+
+![](images/b326febc0d8e890aec789eee1d7590f198242a674f5d20e2749bd0547b189870.jpg)  
+Figure 5: Samples from learned models ${ \bf G } ( { \bf x } , { \bf e } )$ . We show samples from domain transformation models learned from the training data via the MUNIT architecture for Camelyon17-WILDS, FMOW-WILDS, and PACS.
+
+Table 2: WILDS datasets. We report accuracies for Camelyon17 and FMoW. For both datasets, we use the out-of-distribution validation set provided in the WILDS repository to perform model selection.   
+
+<table><tr><td>Algorithm</td><td>Camelyon17-WILDS</td><td>FMoW-WILDS</td></tr><tr><td>ERM</td><td>73.3 ± 9.9</td><td>51.3 (0.4)</td></tr><tr><td>IRM</td><td>60.9 ± 15.3</td><td>51.1 (0.4)</td></tr><tr><td>ARM</td><td>62.1 ± 6.4</td><td>47.9 (0.3)</td></tr><tr><td>CORAL</td><td>59.2 ± 15.1</td><td>49.6 (0.5)</td></tr><tr><td>MBDG</td><td>94.8 ± 0.4</td><td>52.3 ± 0.5</td></tr></table>
+
+![](images/c7f58a9a59649fae9469a8829b6b98a556b3d2fcfb1ce71cc37686a17c5347c2.jpg)  
+Figure 6: Measuing invariance. We measure the invariance of ERM, IRM, and MBDG to images generated by a model $G$ learned for Camelyon17-WILDS.
+
+Measuring $G$ -invariance of trained classifiers. In Section $^ { 4 , }$ we restricted our attention predictors satisfying the $G$ -invariance condition. To test whether our algorithm successfully enforces $G$ - invariance when $G$ is learned from data, we measure the distribution of distReg $( \theta )$ over all of the instances from the training domains of Camelyon17-WILDS for ERM, IRM, and MBDG. In Figure $\bigtriangledown$ observe that whereas MBDG is quite robust to changes under $G$ , ERM and IRM are not nearly as robust. This property is key to the ability of MBDG to learn invariant representations across domains.
+
+Ablation on learning models vs. data augmentation. Rather than learning $G$ from data, a heuristic alternative is to replace the GENERATEIMAGE procedure in Algorithm $\boxed { 1 }$ with standard data augmentation transformations. In Figure $\mathbb { G } ,$ we investigate this approach with five different forms of data augmentation: $\mathbf { B } { + } \mathbf { C }$ (brightness and contrast), CJ (color jitter), and three variants of RandAugment [145] (RA, RA-Geom, and RA-Color). More details concerning these data augmentation schemes are given in Appendix E. The bars in Figure $\sharp$ show that although these schemes offer strong performance in our MBDG framework, the learned model trained using MUNIT performs best.
+
+# 7.3 PACS
+
+In this subsection, we highlight selected results for the PACS dataset. Due to spatial limitations, we report the top-performing baselines in the main text, and defer the full set of results to Appendix $\boxed { \mathrm { E } }$ Notably, MBDG beats the current SOTA by nearly $2 \%$ when averaged over the four domains. Of note in Table $\textcircled { 3 }$ is
+
+Table 3: PACS. We report classification accuracies for PACS. Model-selection was performed via cross-validation.   
+
+<table><tr><td>Algorithm</td><td>A</td><td>C</td><td>P</td><td>s</td><td>Avg</td></tr><tr><td>ERM</td><td>83.2±1.3</td><td>76.8± 1.7</td><td>97.2 ± 0.3</td><td>74.8 ± 1.3</td><td>83.0</td></tr><tr><td>MTL</td><td>85.6 ± 1.5</td><td>78.9 ± 0.6</td><td>97.1 ± 0.3</td><td>73.1 ± 2.7</td><td>83.7</td></tr><tr><td>RSC</td><td>83.7 ± 1.7</td><td>82.9 ± 1.1</td><td>95.6 ± 0.7</td><td>68.1 ± 1.5</td><td>82.6</td></tr><tr><td>MBDG</td><td>80.6 ± 1.1</td><td>79.3± 0.2</td><td>97.0±0.4</td><td>85.2 ± 0.2</td><td>85.6</td></tr></table>
+
+the result on the “sketch” (S) subset, wherein MBDG improves by more than $10 \%$ over the baselines.
+
+# 8 Acknowledgements and disclosure of funding
+
+The authors would like to thank Samuel Sokota for his helpful feedback.
+
+The research of Alexander Robey and Hamed Hassani is supported by NSF Grants 1837253, 1943064, 1934876, AFOSR Grant FA9550-20-1-0111, and DCIST-CRA. Alexander Robey and George J. Pappas are supported by the NSF-Simons Program on the Mathematics of Deep Learning, ARL CRA DCIST W911NF-17-2-0181, and NSF 2038873.
+
+# 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]   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes]   
+(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? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes]
+
+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? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] All of the external code used for this project is open-sourced and freely-available.   
+(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]   
+References [1] Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. nature, 521(7553):436–444, 2015. [2] Carlos Esteves, Christine Allen-Blanchette, Xiaowei Zhou, and Kostas Daniilidis. Polar transformer networks. arXiv preprint arXiv:1709.01889, 2017. [3] Carlos Esteves, Christine Allen-Blanchette, Ameesh Makadia, and Kostas Daniilidis. Learning so (3) equivariant representations with spherical cnns. In Proceedings of the European Conference on Computer Vision (ECCV), pages 52–68, 2018. [4] Max Jaderberg, Karen Simonyan, Andrew Zisserman, and Koray Kavukcuoglu. Spatial transformer networks. arXiv preprint arXiv:1506.02025, 2015. [5] Dan Hendrycks and Thomas Dietterich. Benchmarking neural network robustness to common corruptions and perturbations. arXiv preprint arXiv:1903.12261, 2019. [6] Josip Djolonga, Jessica Yung, Michael Tschannen, Rob Romijnders, Lucas Beyer, Alexander Kolesnikov, Joan Puigcerver, Matthias Minderer, Alexander D’Amour, Dan Moldovan, et al. On robustness and transferability of convolutional neural networks. arXiv preprint arXiv:2007.08558, 2020. [7] Rohan Taori, Achal Dave, Vaishaal Shankar, Nicholas Carlini, Benjamin Recht, and Ludwig Schmidt. Measuring robustness to natural distribution shifts in image classification. Advances in Neural Information Processing Systems, 33, 2020. [8] Dan Hendrycks, Steven Basart, Norman Mu, Saurav Kadavath, Frank Wang, Evan Dorundo, Rahul Desai, Tyler Zhu, Samyak Parajuli, Mike Guo, et al. The many faces of robustness: A critical analysis of out-of-distribution generalization. arXiv preprint arXiv:2006.16241, 2020. [9] Antonio Torralba and Alexei A Efros. Unbiased look at dataset bias. In CVPR 2011, pages 1521–1528. IEEE, 2011.   
+[10] Martin Arjovsky, Léon Bottou, Ishaan Gulrajani, and David Lopez-Paz. Invariant risk minimization. arXiv preprint arXiv:1907.02893, 2019.   
+[11] Kartik Ahuja, Karthikeyan Shanmugam, Kush Varshney, and Amit Dhurandhar. Invariant risk minimization games. In International Conference on Machine Learning, pages 145–155. PMLR, 2020.   
+[12] Chaochao Lu, Yuhuai Wu, Jose Miguel Hernández-Lobato, and Bernhard Schölkopf. Nonlinear ´ invariant risk minimization: A causal approach. arXiv preprint arXiv:2102.12353, 2021.   
+[13] Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Šrndic, Pavel Laskov, ´ Giorgio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Joint European conference on machine learning and knowledge discovery in databases, pages 387–402. Springer, 2013.   
+[14] Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.   
+[15] Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.   
+[16] Eric Wong and J Zico Kolter. Provable Defenses Against Adversarial Examples Via the Convex Outer Adversarial Polytope. arXiv preprint arXiv:1711.00851, 2017.   
+[17] Edgar Dobriban, Hamed Hassani, David Hong, and Alexander Robey. Provable tradeoffs in adversarially robust classification. arXiv preprint arXiv:2006.05161, 2020.   
+[18] Shibani Santurkar, Dimitris Tsipras, and Aleksander Madry. Breeds: Benchmarks for subpopulation shift. arXiv preprint arXiv:2008.04859, 2020.   
+[19] Nimit S Sohoni, Jared A Dunnmon, Geoffrey Angus, Albert Gu, and Christopher Ré. No subclass left behind: Fine-grained robustness in coarse-grained classification problems. arXiv preprint arXiv:2011.12945, 2020.   
+[20] Pang Wei Koh, Shiori Sagawa, Henrik Marklund, Sang Michael Xie, Marvin Zhang, Akshay Balsubramani, Weihua Hu, Michihiro Yasunaga, Richard Lanas Phillips, Sara Beery, et al. Wilds: A benchmark of in-the-wild distribution shifts. arXiv preprint arXiv:2012.07421, 2020.   
+[21] Kai Xiao, Logan Engstrom, Andrew Ilyas, and Aleksander Madry. Noise or signal: The role of image backgrounds in object recognition. arXiv preprint arXiv:2006.09994, 2020.   
+[22] Alexander Robey, Hamed Hassani, and George J Pappas. Model-based robust deep learning. arXiv preprint arXiv:2005.10247, 2020.   
+[23] Eric Wong and J Zico Kolter. Learning perturbation sets for robust machine learning. arXiv preprint arXiv:2007.08450, 2020.   
+[24] Sven Gowal, Chongli Qin, Po-Sen Huang, Taylan Cemgil, Krishnamurthy Dvijotham, Timothy Mann, and Pushmeet Kohli. Achieving robustness in the wild via adversarial mixing with disentangled representations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 1211–1220, 2020.   
+[25] Andre Esteva, Alexandre Robicquet, Bharath Ramsundar, Volodymyr Kuleshov, Mark DePristo, Katherine Chou, Claire Cui, Greg Corrado, Sebastian Thrun, and Jeff Dean. A guide to deep learning in healthcare. Nature medicine, 25(1):24–29, 2019.   
+[26] Li Yao, Jordan Prosky, Ben Covington, and Kevin Lyman. A strong baseline for domain adaptation and generalization in medical imaging. arXiv preprint arXiv:1904.01638, 2019.   
+[27] Haoliang Li, YuFei Wang, Renjie Wan, Shiqi Wang, Tie-Qiang Li, and Alex C Kot. Domain generalization for medical imaging classification with linear-dependency regularization. arXiv preprint arXiv:2009.12829, 2020.   
+[28] Vishnu M Bashyam, Jimit Doshi, Guray Erus, Dhivya Srinivasan, Ahmed Abdulkadir, Mohamad Habes, Yong Fan, Colin L Masters, Paul Maruff, Chuanjun Zhuo, et al. Medical image harmonization using deep learning based canonical mapping: Toward robust and generalizable learning in imaging. arXiv preprint arXiv:2010.05355, 2020.   
+[29] Amy Zhang, Rowan McAllister, Roberto Calandra, Yarin Gal, and Sergey Levine. Learning invariant representations for reinforcement learning without reconstruction. arXiv preprint arXiv:2006.10742, 2020.   
+[30] Luona Yang, Xiaodan Liang, Tairui Wang, and Eric Xing. Real-to-virtual domain unification for end-to-end autonomous driving. In Proceedings of the European conference on computer vision (ECCV), pages 530–545, 2018.   
+[31] Yang Zhang, Philip David, and Boqing Gong. Curriculum domain adaptation for semantic segmentation of urban scenes. In Proceedings of the IEEE International Conference on Computer Vision, pages 2020–2030, 2017.   
+[32] Ryan Julian, Benjamin Swanson, Gaurav S Sukhatme, Sergey Levine, Chelsea Finn, and Karol Hausman. Never stop learning: The effectiveness of fine-tuning in robotic reinforcement learning. arXiv e-prints, pages arXiv–2004, 2020.   
+[33] Anoopkumar Sonar, Vincent Pacelli, and Anirudha Majumdar. Invariant policy optimization: Towards stronger generalization in reinforcement learning. arXiv preprint arXiv:2006.01096, 2020.   
+[34] Eugene Vinitsky, Yuqing Du, Kanaad Parvate, Kathy Jang, Pieter Abbeel, and Alexandre Bayen. Robust reinforcement learning using adversarial populations. arXiv preprint arXiv:2008.01825, 2020.   
+[35] Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. " why should i trust you?" explaining the predictions of any classifier. In Proceedings of the 22nd ACM SIGKDD international conference on knowledge discovery and data mining, pages 1135–1144, 2016.   
+[36] Battista Biggio and Fabio Roli. Wild patterns: Ten years after the rise of adversarial machine learning. Pattern Recognition, 84:317–331, 2018.   
+[37] Gilles Blanchard, Gyemin Lee, and Clayton Scott. Generalizing from several related classification tasks to a new unlabeled sample. Advances in neural information processing systems, 24:2178–2186, 2011.   
+[38] Krikamol Muandet, David Balduzzi, and Bernhard Schölkopf. Domain generalization via invariant feature representation. In International Conference on Machine Learning, pages 10–18, 2013.   
+[39] Gilles Blanchard, Aniket Anand Deshmukh, Urun Dogan, Gyemin Lee, and Clayton Scott. Domain generalization by marginal transfer learning. arXiv preprint arXiv:1711.07910, 2017.   
+[40] Zeyi Huang, Haohan Wang, Eric P Xing, and Dong Huang. Self-challenging improves cross-domain generalization. arXiv preprint arXiv:2007.02454, 2, 2020.   
+[41] Baochen Sun and Kate Saenko. Deep coral: Correlation alignment for deep domain adaptation. In European conference on computer vision, pages 443–450. Springer, 2016.   
+[42] Da Li, Yongxin Yang, Yi-Zhe Song, and Timothy Hospedales. Learning to generalize: Metalearning for domain generalization. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018.   
+[43] Vladimir N Vapnik. An overview of statistical learning theory. IEEE transactions on neural networks, 10(5):988–999, 1999.   
+[44] 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.   
+[45] Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 4700–4708, 2017.   
+[46] Ishaan Gulrajani and David Lopez-Paz. In search of lost domain generalization. arXiv preprint arXiv:2007.01434, 2020.   
+[47] Kaiyang Zhou, Ziwei Liu, Yu Qiao, Tao Xiang, and Chen Change Loy. Domain generalization: A survey. arXiv preprint arXiv:2103.02503, 2021.   
+[48] Jindong Wang, Cuiling Lan, Chang Liu, Yidong Ouyang, and Tao Qin. Generalizing to unseen domains: A survey on domain generalization. arXiv preprint arXiv:2103.03097, 2021.   
+[49] Yuge Shi, Jeffrey Seely, Philip HS Torr, N Siddharth, Awni Hannun, Nicolas Usunier, and Gabriel Synnaeve. Gradient matching for domain generalization. arXiv preprint arXiv:2104.09937, 2021.   
+[50] Alexis Bellot and Mihaela van der Schaar. Accounting for unobserved confounding in domain generalization. arXiv preprint arXiv:2007.10653, 2020.   
+[51] 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, 2016.   
+[52] Isabela Albuquerque, João Monteiro, Mohammad Darvishi, Tiago H. Falk, and Ioannis Mitliagkas. Adversarial target-invariant representation learning for domain generalization. arXiv preprint arXiv:1911.00804, 2019.   
+[53] Haoliang Li, Sinno Jialin Pan, Shiqi Wang, and Alex C Kot. Domain generalization with adversarial feature learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5400–5409, 2018.   
+[54] Saeid Motiian, Marco Piccirilli, Donald A Adjeroh, and Gianfranco Doretto. Unified deep supervised domain adaptation and generalization. In Proceedings of the IEEE international conference on computer vision, pages 5715–5725, 2017.   
+[55] Muhammad Ghifary, David Balduzzi, W Bastiaan Kleijn, and Mengjie Zhang. Scatter component analysis: A unified framework for domain adaptation and domain generalization. IEEE transactions on pattern analysis and machine intelligence, 39(7):1414–1430, 2016.   
+[56] Shoubo Hu, Kun Zhang, Zhitang Chen, and Laiwan Chan. Domain generalization via multidomain discriminant analysis. In Uncertainty in Artificial Intelligence, pages 292–302. PMLR, 2020.   
+[57] Maximilian Ilse, Jakub M Tomczak, Christos Louizos, and Max Welling. Diva: Domain invariant variational autoencoders. In Medical Imaging with Deep Learning, pages 322–348. PMLR, 2020.   
+[58] Kei Akuzawa, Yusuke Iwasawa, and Yutaka Matsuo. Adversarial invariant feature learning with accuracy constraint for domain generalization. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pages 315–331. Springer, 2019.   
+[59] Prithvijit Chattopadhyay, Yogesh Balaji, and Judy Hoffman. Learning to balance specificity and invariance for in and out of domain generalization. In European Conference on Computer Vision, pages 301–318. Springer, 2020.   
+[60] Vihari Piratla, Praneeth Netrapalli, and Sunita Sarawagi. Efficient domain generalization via common-specific low-rank decomposition. In International Conference on Machine Learning, pages 7728–7738. PMLR, 2020.   
+[61] Shiv Shankar, Vihari Piratla, Soumen Chakrabarti, Siddhartha Chaudhuri, Preethi Jyothi, and Sunita Sarawagi. Generalizing across domains via cross-gradient training. arXiv preprint arXiv:1804.10745, 2018.   
+[62] Ya Li, Xinmei Tian, Mingming Gong, Yajing Liu, Tongliang Liu, Kun Zhang, and Dacheng Tao. Deep domain generalization via conditional invariant adversarial networks. In Proceedings of the European Conference on Computer Vision (ECCV), pages 624–639, 2018.   
+[63] Shai Ben-David, John Blitzer, Koby Crammer, Fernando Pereira, et al. Analysis of representations for domain adaptation. Advances in neural information processing systems, 19:137, 2007.   
+[64] Hal Daumé III. Frustratingly easy domain adaptation. arXiv preprint arXiv:0907.1815, 2009.   
+[65] Sinno Jialin Pan, Ivor W Tsang, James T Kwok, and Qiang Yang. Domain adaptation via transfer component analysis. IEEE Transactions on Neural Networks, 22(2):199–210, 2010.   
+[66] 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.   
+[67] Bo Fu, Zhangjie Cao, Mingsheng Long, and Jianmin Wang. Learning to detect open classes for universal domain adaptation. In European Conference on Computer Vision, pages 567–583. Springer, 2020.   
+[68] Vishal M Patel, Raghuraman Gopalan, Ruonan Li, and Rama Chellappa. Visual domain adaptation: A survey of recent advances. IEEE signal processing magazine, 32(3):53–69, 2015.   
+[69] Gabriela Csurka. Domain adaptation for visual applications: A comprehensive survey. arXiv preprint arXiv:1702.05374, 2017.   
+[70] Mei Wang and Weihong Deng. Deep visual domain adaptation: A survey. Neurocomputing, 312:135–153, 2018.   
+[71] Abhimanyu Dubey, Vignesh Ramanathan, Alex Pentland, and Dhruv Mahajan. Adaptive methods for real-world domain generalization. arXiv preprint arXiv:2103.15796, 2021.   
+[72] Aniket Anand Deshmukh, Yunwen Lei, Srinagesh Sharma, Urun Dogan, James W Cutler, and Clayton Scott. A generalization error bound for multi-class domain generalization. arXiv preprint arXiv:1905.10392, 2019.   
+[73] Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In International Conference on Machine Learning, pages 1126–1135. PMLR, 2017.   
+[74] Yogesh Balaji, Swami Sankaranarayanan, and Rama Chellappa. Metareg: Towards domain generalization using meta-regularization. Advances in Neural Information Processing Systems, 31:998–1008, 2018.   
+[75] Qi Dou, Daniel C Castro, Konstantinos Kamnitsas, and Ben Glocker. Domain generalization via model-agnostic learning of semantic features. arXiv preprint arXiv:1910.13580, 2019.   
+[76] Da Li, Jianshu Zhang, Yongxin Yang, Cong Liu, Yi-Zhe Song, and Timothy M Hospedales. Episodic training for domain generalization. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 1446–1455, 2019.   
+[77] Yang Shu, Zhangjie Cao, Chenyu Wang, Jianmin Wang, and Mingsheng Long. Open domain generalization with domain-augmented meta-learning. arXiv preprint arXiv:2104.03620, 2021.   
+[78] Yiying Li, Yongxin Yang, Wei Zhou, and Timothy Hospedales. Feature-critic networks for heterogeneous domain generalization. In International Conference on Machine Learning, pages 3915–3924. PMLR, 2019.   
+[79] Yufei Wang, Haoliang Li, and Alex C Kot. Heterogeneous domain generalization via domain mixup. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pages 3622–3626. IEEE, 2020.   
+[80] Fengchun Qiao, Long Zhao, and Xi Peng. Learning to learn single domain generalization. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 12556–12565, 2020.   
+[81] Marvin Zhang, Henrik Marklund, Abhishek Gupta, Sergey Levine, and Chelsea Finn. Adaptive risk minimization: A meta-learning approach for tackling group shift. arXiv preprint arXiv:2007.02931, 2020.   
+[82] Massimiliano Mancini, Samuel Rota Bulo, Barbara Caputo, and Elisa Ricci. Robust place categorization with deep domain generalization. IEEE Robotics and Automation Letters, 3(3):2093–2100, 2018.   
+[83] Massimiliano Mancini, Samuel Rota Bulò, Barbara Caputo, and Elisa Ricci. Best sources forward: domain generalization through source-specific nets. In 2018 25th IEEE international conference on image processing (ICIP), pages 1353–1357. IEEE, 2018.   
+[84] Da Li, Yongxin Yang, Yi-Zhe Song, and Timothy M Hospedales. Deeper, broader and artier domain generalization. In Proceedings of the IEEE international conference on computer vision, pages 5542–5550, 2017.   
+[85] Zhengming Ding and Yun Fu. Deep domain generalization with structured low-rank constraint. IEEE Transactions on Image Processing, 27(1):304–313, 2017.   
+[86] Shiori Sagawa, Pang Wei Koh, Tatsunori B Hashimoto, and Percy Liang. Distributionally robust neural networks for group shifts: On the importance of regularization for worst-case generalization. arXiv preprint arXiv:1911.08731, 2019.   
+[87] Weihua Hu, Gang Niu, Issei Sato, and Masashi Sugiyama. Does distributionally robust supervised learning give robust classifiers? In International Conference on Machine Learning, pages 2029–2037. PMLR, 2018.   
+[88] Fredrik D Johansson, Nathan Kallus, Uri Shalit, and David Sontag. Learning weighted representations for generalization across designs. arXiv preprint arXiv:1802.08598, 2018.
+
+[89] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. Advances in neural information processing systems, 25:1097– 1105, 2012.
+
+[90] Dan Hendrycks, Norman Mu, Ekin D Cubuk, Barret Zoph, Justin Gilmer, and Balaji Lakshminarayanan. Augmix: A simple data processing method to improve robustness and uncertainty. arXiv preprint arXiv:1912.02781, 2019.
+
+[91] Shuxiao Chen, Edgar Dobriban, and Jane H Lee. Invariance reduces variance: Understanding data augmentation in deep learning and beyond. arXiv preprint arXiv:1907.10905, 2019.
+
+[92] Ling Zhang, Xiaosong Wang, Dong Yang, Thomas Sanford, Stephanie Harmon, Baris Turkbey, Holger Roth, Andriy Myronenko, Daguang Xu, and Ziyue Xu. When unseen domain generalization is unnecessary? rethinking data augmentation. arXiv preprint arXiv:1906.03347, 2019.
+
+[93] Riccardo Volpi, Hongseok Namkoong, Ozan Sener, John Duchi, Vittorio Murino, and Silvio Savarese. Generalizing to unseen domains via adversarial data augmentation. arXiv preprint arXiv:1805.12018, 2018.
+
+[94] Minghao Xu, Jian Zhang, Bingbing Ni, Teng Li, Chengjie Wang, Qi Tian, and Wenjun Zhang. Adversarial domain adaptation with domain mixup. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 6502–6509, 2020.
+
+[95] Shen Yan, Huan Song, Nanxiang Li, Lincan Zou, and Liu Ren. Improve unsupervised domain adaptation with mixup training. arXiv preprint arXiv:2001.00677, 2020.
+
+[96] Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017.
+
+[97] Ian J Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial networks. arXiv preprint arXiv:1406.2661, 2014.
+
+[98] Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4401–4410, 2019.
+
+[99] Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale gan training for high fidelity natural image synthesis. arXiv preprint arXiv:1809.11096, 2018.
+
+[100] Leon A Gatys, Alexander S Ecker, and Matthias Bethge. Image style transfer using convolutional neural networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2414–2423, 2016.
+
+[101] Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In Proceedings of the IEEE international conference on computer vision, pages 2223–2232, 2017.
+
+[102] Xun Huang, Ming-Yu Liu, Serge Belongie, and Jan Kautz. Multimodal unsupervised imageto-image translation. In Proceedings of the European conference on computer vision (ECCV), pages 172–189, 2018.
+
+[103] Amjad Almahairi, Sai Rajeswar, Alessandro Sordoni, Philip Bachman, and Aaron Courville. Augmented cyclegan: Learning many-to-many mappings from unpaired data. arXiv preprint arXiv:1802.10151, 2018.
+
+[104] Paolo Russo, Fabio M Carlucci, Tatiana Tommasi, and Barbara Caputo. From source to target and back: symmetric bi-directional adaptive gan. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 8099–8108, 2018.
+
+[105] Kaiyang Zhou, Yongxin Yang, Timothy Hospedales, and Tao Xiang. Deep domain-adversarial image generation for domain generalisation. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 13025–13032, 2020.
+
+[106] Fabio M Carlucci, Antonio D’Innocente, Silvia Bucci, Barbara Caputo, and Tatiana Tommasi. Domain generalization by solving jigsaw puzzles. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 2229–2238, 2019.
+
+[107] Simon Vandenhende, Bert De Brabandere, Davy Neven, and Luc Van Gool. A three-player gan: generating hard samples to improve classification networks. In 2019 16th International Conference on Machine Vision Applications (MVA), pages 1–6. IEEE, 2019.
+
+[108] Vinicius F Arruda, Thiago M Paixão, Rodrigo F Berriel, Alberto F De Souza, Claudine Badue, Nicu Sebe, and Thiago Oliveira-Santos. Cross-domain car detection using unsupervised image-to-image translation: From day to night. In 2019 International Joint Conference on Neural Networks (IJCNN), pages 1–8. IEEE, 2019.
+
+[109] Mohammad Mahfujur Rahman, Clinton Fookes, Mahsa Baktashmotlagh, and Sridha Sridharan. Multi-component image translation for deep domain generalization. In 2019 IEEE Winter Conference on Applications of Computer Vision (WACV), pages 579–588. IEEE, 2019.
+
+[110] Xiangyu Yue, Yang Zhang, Sicheng Zhao, Alberto Sangiovanni-Vincentelli, Kurt Keutzer, and Boqing Gong. Domain randomization and pyramid consistency: Simulation-to-real generalization without accessing target domain data. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 2100–2110, 2019.
+
+[111] Zak Murez, Soheil Kolouri, David Kriegman, Ravi Ramamoorthi, and Kyungnam Kim. Image to image translation for domain adaptation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4500–4509, 2018.
+
+[112] Daiqing Li, Junlin Yang, Karsten Kreis, Antonio Torralba, and Sanja Fidler. Semantic segmentation with generative models: Semi-supervised learning and strong out-of-domain generalization. arXiv preprint arXiv:2104.05833, 2021.
+
+[113] Haohan Wang, Zexue He, Zachary C Lipton, and Eric P Xing. Learning robust representations by projecting superficial statistics out. arXiv preprint arXiv:1903.06256, 2019.
+
+[114] Hyeonseob Nam, HyunJae Lee, Jongchan Park, Wonjun Yoon, and Donggeun Yoo. Reducing domain gap via style-agnostic networks. arXiv preprint arXiv:1910.11645, 2019.
+
+[115] Nader Asadi, Amir M Sarfi, Mehrdad Hosseinzadeh, Zahra Karimpour, and Mahdi Eftekhari. Towards shape biased unsupervised representation learning for domain generalization. arXiv preprint arXiv:1909.08245, 2019.
+
+[116] David Krueger, Ethan Caballero, Joern-Henrik Jacobsen, Amy Zhang, Jonathan Binas, Dinghuai Zhang, Remi Le Priol, and Aaron Courville. Out-of-distribution generalization via risk extrapolation (rex). arXiv preprint arXiv:2003.00688, 2020.
+
+[117] Chuang Gan, Tianbao Yang, and Boqing Gong. Learning attributes equals multi-source domain generalization. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 87–97, 2016.
+
+[118] Toshihiko Matsuura and Tatsuya Harada. Domain generalization using a mixture of multiple latent domains. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 11749–11756, 2020.
+
+[119] Li Niu, Wen Li, and Dong Xu. Visual recognition by learning from web data: A weakly supervised domain generalization approach. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2774–2783, 2015.
+
+[120] Aharon Ben-Tal, Laurent El Ghaoui, and Arkadi Nemirovski. Robust optimization. Princeton university press, 2009.
+
+[121] Shai Ben-David, John Blitzer, Koby Crammer, Alex Kulesza, Fernando Pereira, and Jennifer Wortman Vaughan. A theory of learning from different domains. Machine learning, 79(1):151–175, 2010.
+
+[122] Shai Ben David, Tyler Lu, Teresa Luu, and Dávid Pál. Impossibility theorems for domain adaptation. In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, pages 129–136. JMLR Workshop and Conference Proceedings, 2010.   
+[123] J Andrew Bagnell. Robust supervised learning. In AAAI, pages 714–719, 2005.   
+[124] Bernhard Schölkopf, Dominik Janzing, Jonas Peters, Eleni Sgouritsa, Kun Zhang, and Joris Mooij. On causal and anticausal learning. arXiv preprint arXiv:1206.6471, 2012.   
+[125] Zachary Lipton, Yu-Xiang Wang, and Alexander Smola. Detecting and correcting for label shift with black box predictors. In International conference on machine learning, pages 3122–3130. PMLR, 2018.   
+[126] Nanyang Ye, Kaican Li, Lanqing Hong, Haoyue Bai, Yiting Chen, Fengwei Zhou, and Zhenguo Li. Ood-bench: Benchmarking and understanding out-of-distribution generalization datasets and algorithms. arXiv preprint arXiv:2106.03721, 2021.   
+[127] Amir Rosenfeld, Richard Zemel, and John K Tsotsos. The elephant in the room. arXiv preprint arXiv:1808.03305, 2018.   
+[128] Joaquin Quiñonero-Candela, Masashi Sugiyama, Neil D Lawrence, and Anton Schwaighofer. Dataset shift in machine learning. Mit Press, 2009.   
+[129] Masanori Koyama and Shoichiro Yamaguchi. Out-of-distribution generalization with maximal invariant predictor. arXiv preprint arXiv:2008.01883, 2020.   
+[130] Elan Rosenfeld, Pradeep Ravikumar, and Andrej Risteski. The risks of invariant risk minimization. arXiv preprint arXiv:2010.05761, 2020.   
+[131] Pritish Kamath, Akilesh Tangella, Danica J Sutherland, and Nathan Srebro. Does invariant risk minimization capture invariance? arXiv preprint arXiv:2101.01134, 2021.   
+[132] Vaishnavh Nagarajan, Anders Andreassen, and Behnam Neyshabur. Understanding the failure modes of out-of-distribution generalization. arXiv preprint arXiv:2010.15775, 2020.   
+[133] Kartik Ahuja, Jun Wang, Amit Dhurandhar, Karthikeyan Shanmugam, and Kush R Varshney. Empirical or invariant risk minimization? a sample complexity perspective. arXiv preprint arXiv:2010.16412, 2020.   
+[134] Kurt Hornik. Approximation capabilities of multilayer feedforward networks. Neural networks, 4(2):251–257, 1991.   
+[135] Kurt Hornik, Maxwell Stinchcombe, and Halbert White. Multilayer feedforward networks are universal approximators. Neural networks, 2(5):359–366, 1989.   
+[136] Deepak Pathak, Philipp Krahenbuhl, and Trevor Darrell. Constrained convolutional neural networks for weakly supervised segmentation. In Proceedings of the IEEE international conference on computer vision, pages 1796–1804, 2015.   
+[137] Steven Chen, Kelsey Saulnier, Nikolay Atanasov, Daniel D Lee, Vijay Kumar, George J Pappas, and Manfred Morari. Approximating explicit model predictive control using constrained neural networks. In 2018 Annual American control conference (ACC), pages 1520–1527. IEEE, 2018.   
+[138] Thomas Frerix, Matthias Nießner, and Daniel Cremers. Homogeneous linear inequality constraints for neural network activations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pages 748–749, 2020.   
+[139] Brandon Amos and J Zico Kolter. Optnet: Differentiable optimization as a layer in neural networks. In International Conference on Machine Learning, pages 136–145. PMLR, 2017.   
+[140] Sathya N Ravi, Tuan Dinh, Vishnu Lokhande, and Vikas Singh. Constrained deep learning using conditional gradient and applications in computer vision. arXiv preprint arXiv:1803.06453, 2018.   
+[141] Priya L Donti, David Rolnick, and J Zico Kolter. Dc3: A learning method for optimization with hard constraints. arXiv preprint arXiv:2104.12225, 2021.   
+[142] Luiz FO Chamon, Santiago Paternain, Miguel Calvo-Fullana, and Alejandro Ribeiro. The empirical duality gap of constrained statistical learning. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pages 8374–8378. IEEE, 2020.   
+[143] Dimitri P Bertsekas and Athena Scientific. Convex optimization algorithms. Athena Scientific Belmont, 2015.   
+[144] Yann LeCun, Corinna Cortes, and CJ Burges. Mnist handwritten digit database. ATT Labs [Online]. Available: http://yann. lecun. com/exdb/mnist, 2, 2010.   
+[145] 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.   
+[146] Thomas M Cover. Elements of information theory. John Wiley & Sons, 1999.   
+[147] Richard F Bass. Real analysis for graduate students. Createspace Ind Pub, 2013.   
+[148] Stephen Boyd, Stephen P Boyd, and Lieven Vandenberghe. Convex optimization. Cambridge university press, 2004.   
+[149] Miguel A Goberna and MA López. Recent contributions to linear semi-infinite optimization. 4OR, 15(3):221–264, 2017.   
+[150] Luiz Chamon and Alejandro Ribeiro. Probably approximately correct constrained learning. Advances in Neural Information Processing Systems, 33, 2020.   
+[151] Elias M Stein and Rami Shakarchi. Functional analysis: introduction to further topics in analysis, volume 4. Princeton University Press, 2011.   
+[152] Luiz FO Chamon, Santiago Paternain, Miguel Calvo-Fullana, and Alejandro Ribeiro. Constrained learning with non-convex losses. arXiv preprint arXiv:2103.05134, 2021.   
+[153] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+[154] Irina Higgins, David Amos, David Pfau, Sebastien Racaniere, Loic Matthey, Danilo Rezende, and Alexander Lerchner. Towards a definition of disentangled representations. arXiv preprint arXiv:1812.02230, 2018.   
+[155] Muhammad Ghifary, W Bastiaan Kleijn, Mengjie Zhang, and David Balduzzi. Domain generalization for object recognition with multi-task autoencoders. In Proceedings of the IEEE international conference on computer vision, pages 2551–2559, 2015.   
+[156] Asha Anoosheh, Eirikur Agustsson, Radu Timofte, and Luc Van Gool. Combogan: Unrestrained scalability for image domain translation. In Proceedings of the IEEE conference on computer vision and pattern recognition workshops, pages 783–790, 2018.   
+[157] Yunjey Choi, Youngjung Uh, Jaejun Yoo, and Jung-Woo Ha. Stargan v2: Diverse image synthesis for multiple domains. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 8188–8197, 2020.

parse/train/SyXNErg0W/SyXNErg0W.md

@@ -0,0 +1,310 @@
+# SOFTMAX SUPERVISION WITH ISOTROPIC NORMALIZATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+The softmax function is widely used to train deep neural networks for multi-class classification. Despite its outstanding performance in classification tasks, the features derived from the supervision of softmax are usually sub-optimal in some scenarios where Euclidean distances apply in feature spaces. To address this issue, we propose a new loss, dubbed the isotropic loss, in the sense that the overall distribution of data points is regularized to approach the isotropic normal one. Combined with the vanilla softmax, we formalize a novel criterion called the isotropic softmax, or isomax for short, for supervised learning of deep neural networks. By virtue of the isomax, the intra-class features are penalized by the isotropic loss while inter-class distances are well kept by the original softmax loss. Moreover, the isomax loss does not require any additional modifications to the network, mini-batches or the training process. Extensive experiments on classification and clustering are performed to demonstrate the superiority and robustness of the isomax loss.
+
+# 1 INTRODUCTION
+
+Recent years have witnessed significant progress in image classification tasks with convolution neural networks (CNN) LeCun et al. (1998); Krizhevsky et al. (2012). For classification problems, the softmax is a suitable criterion for supervised learning since it is capable of training network parameters to generate discriminative features for hyperplanes to distinguish different classes. Due to its end-to-end characteristic, CNN is amenable to learning such that we only need to feed the network with plenty of training samples. Therefore, the softmax is the most fundamental classifier applied in architectures of deep learning.
+
+However, there are still defects of the softmax loss1. Features extracted by convolution layers work best only with softmax classifier. When we apply these feature vectors in other tasks such as image retrieval with $k$ -nearest neighbors $k$ -NN) or clustering with K-means, the results are usually suboptimal, as shown in Figure 1. To separate different classes is the sole purpose of softmax classifier, and it does not ensure that the distances (generally Euclidean distances) within the same class are smaller than inter-class ones. In order to extract better features not only for classification powered by the softmax classifier but for other tasks using distances of feature vectors, many approaches have been proposed in the past years.
+
+One way is adding some new loss terms to the original softmax loss. The center loss Wen et al. (2016) penalizes distances of training samples to their corresponding class centers, thus enhancing the compactness of each class. Since this loss cannot extend the distances between class centers, the result depends heavily on the center initialization of all classes. Also, a relatively small batch size will seriously affect the performance of the algorithm, because centers cannot be accurately calculated with limited examples in a batch, especially for datasets with plenty of classes. The contrastive-center loss Qi & Su (2017) combines the center loss and the contrastive loss Sun et al. (2014) together to penalize distances of samples in the same classes and enlarge inter-class distances. It works well on the CIFAR-10 classification task Krizhevsky & Hinton (2009) and the LFW verification task Huang et al. (2008). To gain good performance, however, this loss needs to carefully select data batches for training too.
+
+![](images/253bc204829d1fdb99e508602a0b3eaffd1da689b739b19dbbb5369767b90d23.jpg)  
+Figure 1: (a) Features extracted by CNN with softmax loss are separated well into two classes by a line (hyperplanes in high-dimensional spaces), but lots of orange samples are included in a neighborhood (the blue circle) of a blue sample. (b) The performance of agglomerative clustering Beeferman & Berger (2000) on these features is poor.
+
+Some other strategies aim at solving the problem in a different way. The triplet loss Schroff et al. (2015) comes up with a novel method. Instead of exploiting the softmax loss, they remove the final logits layer of network and directly minimize Euclidean distances between anchors and positive samples while maximizing distances of anchors to negative samples in triplets. However, the number of different triplets are much more than that of training samples, leading to that selecting proper triplets is crucial for the triplet loss. Or inappropriate triplets will result in slow convergence. What’s more, the scalar margin in the triplet loss and the learning strategy influence the final performance of the model as well. To sum up, the principle of the triplet loss is straightforward and plausible, but the parameters and the “semi-hard triplets mining” approach make this algorithm hard to implement.
+
+Methods mentioned above are all based on supervised optimization, meaning that they all depend on sample labels to learn discriminative features. In this paper, we propose a simple approach, named isotropic normalization, that reshapes data distribution towards easy classification without the aid of labels. We firstly analyze the distribution of features extracted by CNNs supervised by the softmax loss. Elliptical shapes of feature distributions lead to intra-class distances even greater than inter-class distances, indicating that the softmax loss needs to be improved for tasks using feature distances. Then we attempt to modify the feature distribution according to the global distribution itself rather than information from sample labels. Combined with the vanilla softmax, we propose a new loss, called the isotropic softmax (isomax for short) loss. For the isomax, the intra-class distances of the features can be well minimized by the isotropic loss, and at the same time, the vanilla softmax loss ensures the inter-class separability. We perform extensive experiments with different networks and different datasets to illustrate the effectiveness, simplicity and portability of our method.
+
+# 2 ANALYSIS OF SOFTMAX
+
+In this section, we introduce the softmax loss and analyze its limitations with visualization of 2- D features. According to the feature distribution, we show why these features are not the optimal option in tasks that use feature distances. Then we present our approach to ameliorating the feature distribution.
+
+# 2.1 SOFTMAX LOSS
+
+Suppose that we have $N$ training samples of $n$ classes. Let $x _ { i } \in \mathbb { R } ^ { d }$ denote the $i$ -th image feature vector and $y _ { i }$ its label. Then softmax loss can be formulated as
+
+$$
+\mathcal { L } _ { S } = \sum _ { i = 1 } ^ { N } - \log \left( \frac { \exp ( f _ { y _ { i } } ) } { \sum _ { j = 1 } ^ { n } \exp ( f _ { j } ) } \right) .
+$$
+
+For typical neural networks, $f$ denotes the output of a fully connected layer with weights $W$ (a parameter matrix with $n$ columns) and bias $b$ . Then the softmax loss can be rewritten as Equation 2 Liu et al. (2016)
+
+$$
+\begin{array} { r l r } {  { \mathcal L _ { S } = - \sum _ { i = 1 } ^ { N } \log \frac { \exp ( W _ { y _ { i } } ^ { T } x _ { i } + b _ { y _ { i } } ) } { \sum _ { j = 1 } ^ { n } \exp ( W _ { j } ^ { T } x _ { i } + b _ { j } ) } } } \\ & { } & { = - \sum _ { i = 1 } ^ { N } \log \frac { \exp ( \| W _ { y _ { i } } \| \| x _ { i } \| \cos ( \theta _ { y _ { i } } ) + b _ { y _ { i } } ) } { \sum _ { j = 1 } ^ { n } \exp ( \| W _ { j } \| \| x _ { i } \| \cos ( \theta _ { j } ) + b _ { j } ) } , } \end{array}
+$$
+
+![](images/7a1fc78915df369ef62c973ae7ec851b4edcff4a9f0f54065f5e6faf474aadfe.jpg)  
+Figure 2: Visualization of MNIST. (a) Features of 1000 MNIST samples obtained with softmax loss. Different colors represent different classes. (b) Normalize 2-D features to a circle. Best viewed in color. (c) Schematic illustration of our method. We enforce a restriction on features in the approximately orthogonal direction from that of softmax to reshape the feature distribution.
+
+Table 1: The structure of our network for the experiment of MNIST. It is similar to LeNet LeCun et al. (1998), but we add some filters and reduce the number of neurons in the last hidden layer to 2.   
+
+<table><tr><td rowspan=1 colspan=1>Layer</td><td rowspan=1 colspan=1>input</td><td rowspan=1 colspan=1>output</td><td rowspan=1 colspan=1>kernel</td><td rowspan=1 colspan=1>param</td></tr><tr><td rowspan=1 colspan=1>conv1</td><td rowspan=1 colspan=1>28×28×3</td><td rowspan=1 colspan=1>28×28×32</td><td rowspan=1 colspan=1>5×5,1</td><td rowspan=1 colspan=1>2.4K</td></tr><tr><td rowspan=1 colspan=1>pool1</td><td rowspan=1 colspan=1>28×28×32</td><td rowspan=1 colspan=1>14×14×32</td><td rowspan=1 colspan=1>2×2,2</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>conv2</td><td rowspan=1 colspan=1>14×14×32</td><td rowspan=1 colspan=1>14×14×64</td><td rowspan=1 colspan=1>5×5,1</td><td rowspan=1 colspan=1>51.2K</td></tr><tr><td rowspan=1 colspan=1>pool2</td><td rowspan=1 colspan=1>14×14x64</td><td rowspan=1 colspan=1>7×7×64</td><td rowspan=1 colspan=1>2×2,2</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>fc1</td><td rowspan=1 colspan=1>3136</td><td rowspan=1 colspan=1>1024</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3.2M</td></tr><tr><td rowspan=1 colspan=1>drop</td><td rowspan=1 colspan=1>1024</td><td rowspan=1 colspan=1>1024</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>fc2</td><td rowspan=1 colspan=1>1024</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2K</td></tr></table>
+
+where $W _ { j }$ denotes the $j$ -th column of $W$ . Since $W _ { j }$ and $x _ { i }$ are all vectors, the inner product of them can be formulated as $\| W _ { j } \| \| x _ { i } \| \cos ( \theta _ { j } )$ , where $\bar { \theta _ { j } }$ is the angle of $W _ { j }$ and $x _ { i }$ . After formulating the softmax loss to an inner product form with a factor $\cos ( \theta )$ , it is clear that the softmax classifier is prone to enforce examples in a class have similar $\theta$ and different $\theta$ for different classes. This property of the softmax leads to the thin elliptical shape of feature distribution for each class with respect to the global center.
+
+# 2.2 VISUALIZATION ON MNIST
+
+To analyze the feature distribution, it is a feasible way to visualize data points in a 2-D plane or 3-D space. MNIST LeCun et al. (1995) is a hand-written digit dataset of 0-9 in 10 classes, with 60,000 training samples and 10,000 testing samples. Image size of both subsets is $2 8 \times 2 8$ . Since MNIST is such a simple dataset that even we reduce the dimension of feature vectors to 2, the softmax classifier is applicable to maintain $98 \%$ accuracy. So we choose it as our first example to describe the feature distribution.
+
+The network architecture is presented in Table 1. We train the network with 60,000 training samples without data argumentation, and randomly sample 1000 testing images in 10,000 testing set. Since the dimension of feature vectors is 2, we can plot features of testing samples, as shown in Figure 2 (a). It is evident that minimizing the softmax loss leads to the separability of different classes. But for some samples, especially those near to the center of overall distribution, inter-class distances are even smaller than intra-class distances.
+
+# 2.3 RESTRICTION TO FEATURE DISTRIBUTION
+
+Figure 2 (a) directly shows overall distribution under supervision of softmax loss. The thin shape of feature distribution of a certain class is the inevitable result of the softmax loss according to our previous analysis, which causes the large intra-class distances and small inter-class distances.
+
+Apart from the softmax loss, if we can find a new “force” which can reshape the thin distribution to a “medium build” (Figure 2 (c)) , the inter-class distances will be kept by the softmax loss while the intra-class distances will be guaranteed by the new force.
+
+For a certain class $i$ , we can regard features of this class as a normal distribution $\textstyle { \mathcal { N } } ( \mu _ { i } , \Sigma _ { i } )$ where $\mu _ { i }$ is the mean of this class and $\Sigma _ { i }$ is the covariance matrix. Then there exits an orthogonal matrix $U$ and an eigenvalue-diagonal matrix $D$ satisfying $\Sigma _ { i } = U D U ^ { \top }$ . Diagonal values in $D$ can describe the shape of the normal distribution. If these eigenvalues are almost the same (with small variance), then the distribution of features is like an isotropic normal one. This analysis inspires us to devise a simple algorithm to optimize the shape of each class.
+
+# 3 ISOTROPIC SOFTMAX
+
+In this section, we describe our approach in detail. The relevant classification criteria are discussed as well.
+
+# 3.1 OUR APPROACH
+
+Inspired by Figure 2 (c) and the discussion of isotropic multivariate normal distribution, the spatial distribution of each class will be more compact if we penalize features such that $\mathcal { N } ( \mu _ { i } , \Sigma _ { i } )$ of class $i$ will be like an isotropic one, say that the variances of different dimensions are approximately uniform.
+
+# 3.1.1 ISOTROPIC SOFTMAX LOSS
+
+Here we present the isotropic loss that action on data points with the complementary effect compared with the softmax function, writing that
+
+$$
+\begin{array} { l } { \displaystyle \mathcal { L } _ { I } = \frac { 1 } { N - 1 } \sum _ { i = 1 } ^ { N } ( \mathcal { D } _ { i } - \bar { \mathcal { D } } ) ^ { 2 } } \\ { \displaystyle \quad = \frac { 1 } { N - 1 } \sum _ { i = 1 } ^ { N } \bigg ( \| x _ { i } - \bar { x } \| _ { 2 } ^ { 2 } - \frac { \sum _ { i = 1 } ^ { N } \| x _ { i } - \bar { x } \| _ { 2 } ^ { 2 } } { N } \bigg ) ^ { 2 } , } \end{array}
+$$
+
+where $\bar { x }$ denotes the center of $x _ { i }$ , i.e. $\begin{array} { r } { \bar { x } = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } x _ { i } } \end{array}$ . In Equation 3, $\mathcal { L } _ { I }$ denotes our new isotropic $\| x _ { i } - \bar { x } \| _ { 2 } ^ { 2 }$ . Specially, take $d { = } 2$ in Figure 2 for instance. The $\mathcal { L } _ { I }$ loss will push points near to the circle of radius $\bar { \mathcal D }$ and $\bar { x }$ for the circle center.
+
+It is worth mentioning that this method is essentially different from feature normalization after training. We perform this isotropic regularizer during training and $\bar { \mathcal D }$ varies, meaning that the shape of each class will be deformed with softmax supervision and isotropic regularization towards easy classification during iterations.
+
+Obviously, it is impractical and inefficient to calculate the $\mathcal { L } _ { I }$ loss function for all training examples in each iteration. However, we can compute the estimates of $\bar { x }$ and $\bar { \mathcal D }$ within a batch if we randomly select samples in a training batch. The randomness of the data and the globality of the loss function guarantee the plausibility of such manipulation. Thanks to the decoupling of the isotropic loss and class labels, our loss remains unchanged from the whole training set to a batch. Details are shown in Algorithm 1.
+
+<table><tr><td colspan="2">Algorithm1Isotropic Normalization ina Mini-Batch</td></tr><tr><td colspan="2">Input: A batch of feature B={x1,.., xm} produced by deep neural networks</td></tr><tr><td>Output:isotropic loss L for a mini-batch 11m</td><td></td></tr><tr><td>xB← m≥i=1xi fori=1...m do</td><td>//calculate the distribution center //calculate the distance to the center</td></tr><tr><td>Di←|xi-xBll2 end for DB↑ 1 m Di m</td><td>//calculate the mean distance</td></tr></table>
+
+![](images/c67225d35b1c4abce577b177f827228d04742ceb68e8ce4390a740653bce776b.jpg)  
+Figure 3: Feature distribution of MNIST. 10 different colors represent 10 different classes of digits 0-9. (a) and (b) Combination of isotropic loss and softmax loss with relatively small $\alpha$ supervise the network to extract better features. (c) Isotropic loss dominates the training and softmax loss loses its role due to a large $\alpha$ .
+
+The total joint loss named the isotropic softmax (isomax) loss is formulated as
+
+$$
+\begin{array} { r l } & { \mathcal { L } = \mathcal { L } _ { S } + \alpha \mathcal { L } _ { I } } \\ & { \quad = - \displaystyle \sum _ { i = 1 } ^ { m } \log \frac { \exp ( W _ { y _ { i } } ^ { T } x _ { i } + b _ { y _ { i } } ) } { \sum _ { j = 1 } ^ { n } \exp ( W _ { j } ^ { T } x _ { i } + b _ { j } ) } + \alpha \frac { \sum _ { i = 1 } ^ { m } ( \mathcal { D } _ { i } - \bar { D } _ { B } ) ^ { 2 } } { m - 1 } , } \end{array}
+$$
+
+where $\mathcal { L } _ { S }$ is the softmax loss and $\alpha$ controls the trade-off between the isotropic loss and the softmax loss. A small $\alpha$ may be not enough to form an isotropic distribution while a large $\alpha$ will restrain the supervision of the softmax loss, making features indistinguishable near the hypersphere. In the following section, we will discuss the influence of different $\alpha$ .
+
+As mentioned above, the loss is the unbiased variance estimate of distance $\lVert x _ { i } - \bar { x } \rVert _ { 2 } ^ { 2 }$ , which is differentiable to $x _ { i }$ , and $x _ { i }$ is the output of the last hidden layer of CNNs. According to chain rule, our loss term is differentiable to parameters of networks. SGD Bottou (2010), Adam Kingma & Ba (2014), RMSProp Tieleman & Hinton (2012) or other learning methods for neural networks can be used to minimize the isomax loss. As an unsupervised loss term, the optimization of the isotropic loss requires no conditions about training batches or class labels. All we need to do is combining this new loss with the original softmax loss and training the network directly via backpropagation.
+
+# 3.1.2 BALANCE OF TWO LOSS TERMS
+
+To find out the hyper-parameter $\alpha$ , we first examine the 2-D distribution of MNIST. After 20,000 step training, the feature distribution of 1,000 test samples are shown in Figure 3. We can see that the result is much like what we expect when $\alpha { = } 0 . 0 0 5$ or $\alpha { = } 0 . 0 5$ . But for a large $\alpha$ , the force of the isotropic loss is so powerful that the softmax loss loses its ability to shape classes.
+
+During training, we find that even very small $\alpha$ is able to cut down the isotropic loss quickly, the only influence of $\alpha$ is the speed of convergence. But if $\alpha > 0 . 1$ , not only the training procedure converges slowly, but the result is also unacceptable. This threshold is suitable for almost all networks and datasets we try. In following sections, unless otherwise specified, the value of $\alpha$ is set to 0.05.
+
+# 3.1.3 COMPARISON WITH FEATURE NORMALIZATION
+
+Since our loss tends to normalize features to a hypersphere surface, one alternative way may be simply normalizing features to a hypersphere, specifically a circle for 2-D features (Figure 2 (b)). It needs no additional operation or loss term during training and may work well in low dimensions, but it does not mean that feature normalization will work in higher dimensions. The reason is that in high-dimensional space, the hyperplanes of the softmax classifier is much more complex. If we normalize the features to a hypersphere after training, many features from different classes would overlap together on the hyperspherical surface.
+
+In fact, isotropic loss, as a part of isomax loss, is not a normalization operation. It only tries to gather the feature points around the sphere surface, which is a slow process. So features cannot be directly stacked together. Moreover, even if features from different classes become close to each other around the sphere surface, softmax loss, as a another supervision in isomax loss, is capable of
+
+<table><tr><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=1>Steps to converge</td><td rowspan=1 colspan=1>Label Info.</td><td rowspan=1 colspan=1>Accuracy Var.</td><td rowspan=1 colspan=1>TrainingTricks</td></tr><tr><td rowspan=1 colspan=1>CenterLoss</td><td rowspan=1 colspan=1>35K steps</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>±0.5%</td><td rowspan=1 colspan=1>Batch selection. Center initialization.</td></tr><tr><td rowspan=1 colspan=1>Triplet Loss</td><td rowspan=1 colspan=1>100K+ steps</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>Triplet mining. Optimization method.</td></tr><tr><td rowspan=1 colspan=1>Isotropic Loss</td><td rowspan=1 colspan=1>20K steps</td><td rowspan=1 colspan=1>No</td><td rowspan=1 colspan=1>±0.2%</td><td rowspan=1 colspan=1>No tricks.</td></tr></table>
+
+Table 2: Comparison of three methods. We train these three methods for several trials on MNIST. We can see that our method converges more quickly and are more stable. Training tricks are also summarized. Fluctuation of accuracy on testing set is a measure of algorithm stability and replicability. Here only the fluctuation on softmax classification is compared (triplet loss does not have a softmax classifier). More details of performance can be found in the Experiment section.
+
+![](images/d5f7976157cb4a6ae4ef741fc502e94566b4fc59b5c7a1c92e901d115384a22b.jpg)  
+Figure 4: Illustrative comparison of isomax loss and center loss. When we retrain networks with isomax loss, the overall distribution of test samples is robust and stable. For center loss, different training batches form different centers, and finally result in different global distributions.
+
+pushing different feature points away again. Therefore our method is totally different from feature normalization after training.
+
+# 3.2 COMPARISON WITH OTHER WORKS
+
+There are some related works with the same purpose as ours such as the triplet loss Schroff et al. (2015) and the center loss Wen et al. (2016). We will analyze the properties of compared methods in this section. Table 2 concisely shows the merits of each method. We also discuss Batch Normalization Ioffe & Szegedy (2015) since it is an operation on feature distributions too, though for different purpose.
+
+# 3.2.1 CENTER LOSS
+
+Center loss is an excellent work to solve the problem of large intra-class distances. Jointly supervised by the center loss and the softmax loss, the features of same class can gather together. Equation 5 gives the formulation
+
+$$
+\begin{array} { l } { \displaystyle \mathcal { L } = \mathcal { L } _ { S } + \alpha \mathcal { L } _ { C } } \\ { \displaystyle \quad = - \sum _ { i = 1 } ^ { m } \log \frac { \exp ( W _ { y _ { i } } ^ { T } x _ { i } + b _ { y _ { i } } ) } { \sum _ { j = 1 } ^ { n } \exp ( W _ { i } ^ { T } x _ { i } + b _ { i } ) } + \frac { \lambda } { 2 } \sum _ { i = 1 } ^ { m } \| x _ { i } - c _ { y _ { i } } \| _ { 2 } ^ { 2 } , } \end{array}
+$$
+
+where $c _ { y _ { i } }$ is the center of the $i$ -th sample class in a batch. Centers are learned in each iteration and each batch. Though the authors of this work give some methods to avoid perturbations of centers, centers are still difficult to determine, especially when the samples from one class are limited in a batch. We train models of MNIST with the center loss and the isomax loss both twice and the experimental conditions are all the same except for the different loss terms. Results are shown in Figure 4. It is obvious that once a center is not well established, the features of this class will gather near this center, incurring that the overall distribution of associated features is unfavorable for classification. Instead the results of our isomax loss are more stable and robust. What’s more, the fluctuating convergence and the additional calculation of centers make the training time longer. In our algorithm, the isotropic loss is an unsupervised loss. This loss function learns a better distribution directly from distribution itself without using labels of training data. All we need is randomly selecting samples from the training set like what we do with the softmax loss.
+
+# 3.2.2 TRIPLET LOSS
+
+The triplet loss is employed to supervise the learning of an Euclidean embedding per image. The loss is formulated as
+
+$$
+\sum _ { i } ^ { N } [ \| f ( x _ { i } ^ { a } ) - f ( x _ { i } ^ { p } ) \| _ { 2 } ^ { 2 } - \| f ( x _ { i } ^ { a } ) - f ( x _ { i } ^ { n } ) \| + \alpha ] _ { + }
+$$
+
+where $f ( x )$ is an embedding generated by CNNs, the selected anchor $\boldsymbol { x } _ { i } ^ { a }$ , the positive sample $x _ { i } ^ { p }$ , and the negative sample $\boldsymbol { x } _ { i } ^ { n }$ constitute a triplet. The triplet loss directly minimizes the Euclidean distance of samples from the same class and maximizes the distance of samples from the different class until reaching a selection margin $\alpha$ .
+
+For the triplet loss, the learning strategy and the triplet selection are critical for performance. By many practices, we find that the model is sensitive to the learning rate and the learning method. Also, the converging speed is much lower than that of the model supervised by the softmax loss. Due to the massive combination of triplets and the learning tricks it requires, the results we get are not so good. To sum up, the training with the triplet loss is a laborious task.
+
+# 3.2.3 BATCH NORMALIZATION
+
+Batch Normalization is a method to reduce internal covariate shift in data Shimodaira (2000). They introduce feature $\boldsymbol { x } \mathbf { = } ( x ^ { ( 1 ) } , . . . , x ^ { ( k ) } , . . . , x ^ { ( d ) } )$ $\gamma ^ { ( k ) }$ and $\beta ^ { ( k ) }$ for each activation to a new feature $x ^ { ( k ) }$ in a $\boldsymbol { y } { = } ( y ^ { ( 1 ) } , { \ldots } , y ^ { ( k ) } , { \ldots } , y ^ { ( d ) } )$ $d$ -dimensional feature $x$ , and transform original by
+
+$$
+y ^ { ( k ) } = \gamma ^ { ( k ) } \frac { x ^ { ( k ) } - \mathrm { E } [ x ^ { ( k ) } ] } { \sqrt { \mathrm { V a r } [ x ^ { ( k ) } ] } } + \beta ^ { ( k ) } .
+$$
+
+By adding Batch-Norm layer (BN layer) to a certain layer in networks, each dimension of the feature of this layer is transformed according to Equation 7. Training samples in a batch are used for feature distribution transformation, which seems similar to our approach.
+
+Though batch normalization and our method both aim at distribution transformation, they are totally different from operation and functionality. According to Equation 7, the normalization operation is along the axis of one dimension of features. Batch normalization constrains the values of each dimension of features within a reasonable range, while our method normalizes Euclidean distances of feature vectors with respect to the global center of data distribution. To make it clearer, we interpret a simplified example by letting $\gamma ^ { ( k ) } { = } 1$ and $\beta ^ { ( k ) } { = } 0$ . As each dimension is normalized, batch normalization transforms features inside a hypersphere. Our loss term tries to push features onto the spherical surface, thus reducing the variance of distances to the distribution center (spherical center). Batch normalization prevents the training from getting stuck. As for our approach, a final feature map with small intra-class distance and large inter-class distance is our target. In fact, these two seemingly similar operations are mutually independent. If we use batch normalization for the last hidden layer, the $x$ in Algorithm 1 will be replaced by the output $y$ of batch normalization. In the following experiments in the next section, batch normalization is applied together with our new loss.
+
+Briefly in summary, batch normalization is a local normalization on a certain feature map to improve the training of the network. Ours is a global geometric supervision on the overall feature distribution of the last hidden layer to acquire better representations.
+
+# 4 EXPERIMENTS
+
+We evaluate the isomax on three tasks: image classification, feature clustering and face verification. Experiments are performed on four datasets: MNIST, CIFAR-10, a subset of ILSVRC2012 Deng et al. (2012) with 200 classes, and CASIA-WebFace Yi et al. (2014). We divide CASIA-WebFace into training and testing sets with a ratio of 2:1. These four datasets are very different in data attributes, data volumes, and class numbers. For the classification task, the testing sets of these four datasets are all used. For the clustering task, the Face Recognition Grand Challenge (FRGC) Phillips et al. (2005) dataset is also used for testing. For face verification, we use the Labeled Faces in the
+
+Wild (LFW) benchmark dataset. To compare fairly for each dataset, we train three models under different supervision: the softmax loss, the center-softmax joint loss and our isomax loss using the same training methodology and network architecture. For verification task, we also train a model with the triplet loss since it achieves state-of-the-art performance in LFW. All the experiments are implemented with TensorFlow Abadi et al. (2016).
+
+# 4.1 EXPERIMENT SETTINGS
+
+# 4.1.1 MNIST AND CIFAR-10
+
+For MNIST, the network we use is shown in Table 1. For CIFAR-10, inspired by the architecture of VGG-net Simonyan & Zisserman (2014), we design our network in this way: 3 cascaded convolution blocks followed by a dropout Hinton et al. (2012) layer and then a fully-connected layer . There are 4 cascaded convolution layers with size of $3 \times 3$ (stride ${ \mathop : } = 1$ ) and a max-pooling layer with size of $2 \times 2$ (stride $^ { = 2 }$ ) in each block. Filter numbers in blocks are 64, 96 and 128. We do not use data augmentation on these two datasets but use a dropout of 0.8. The initial learning rate is 0.1 and decays with an exponential rate of 0.96 every 1000 steps. The Adagrad method is employed for optimization. Batch size is 128.
+
+# 4.1.2 ILSVRC-SUB
+
+For this dataset, there are 200 classes and about 1300 images in each class. The Inception-ResNetv1 network Szegedy et al. (2017) is applied. We do not use the input size of $2 9 9 \times 2 9 9$ according to the original paper, but $1 6 0 \times 1 6 0$ for simplicity of calculation. In training phase, we resize the short edge of image to 182, and randomly crop a $1 6 0 \times 1 6 0$ window. The random adjustment of hue, brightness, contrast and saturation is applied. In testing phase, we resize the short edge to 160 and crop a square sub-image in the center. We harness Adagrad and a decaying learning rate that starts at 0.05 and decays with an exponential rate of 0.94 every two epochs. Batch size is 128.
+
+# 4.1.3 CASIA-WEBFACE
+
+CASIA-WebFace contains $0 . 4 9 \mathbf { M }$ labeled face images from over 10,575 individuals. We firstly exploit MTCNN Zhang et al. (2016) to align face images based on 5 points. Then two-thirds of images from each individual (about 0.32M totally) are randomly selected to train the InceptionResNet-v1 network. During training, we resize images to $1 8 2 \times 1 8 2$ and randomly crop a $1 6 0 \times 1 6 0$ window, while for testing we directly resize images to $1 6 0 \times 1 6 0$ . Random left-to-right flipping is also used for training. The training method we use is RMSProp with decay of 0.9 and $\epsilon = 1 . 0$ . Batch size is 512. In fact, this relatively large batch size is chosen for center loss since centers need to be updated in a batch and the number of classes of CASIA dataset is too large. We use an initial learning rate of 0.1, divided by 10 after 50 epochs and 65 epochs.
+
+# 4.2 CLASSIFICATION
+
+The softmax loss is our baseline, which is designed for image classification. So we firstly evaluate our model on this kind of task. To ensure that our modification to the original softmax loss has no negative impact on the softmax classifier, we firstly evaluate the accuracy on four datasets. Then, to illustrate the superiority of our model in distance-based tasks, we also report the $k$ -NN classification results using feature vectors attained by the supervision of compared losses. Table 3 shows the experimental results.
+
+We observe that our algorithm does not deteriorate the performance of the softmax classifier, while in $k$ -NN classification tasks, our proposed algorithm performs better, especially for datasets with many classes. For these datasets, it is more essential to place features of different classes in a finite feature space properly. To show details of training, we take the CASIA-WebFace dataset as an example, plotting the curve of accuracy during training process in Figure 5.
+
+Another interesting evaluation we analyze here is shown in Figure 6. In three contrast experiments, we monitor the value of center loss, which is only minimized as a loss term in the experiment of center loss. However, for each dataset, the isomax loss makes the center loss much lower, though we do not take the initiative to optimize it. As the center loss is a measure of intra-class distance, this proves that, by reshaping the overall global distribution, our algorithm can reduce the distance within a class more effectively.
+
+Table 3: Classification results.   
+
+<table><tr><td rowspan=2 colspan=1>Datasets</td><td rowspan=2 colspan=1>Methods</td><td rowspan=2 colspan=1>SoftmaxAcc (%)</td><td rowspan=1 colspan=3>k-NN Acc (%)</td></tr><tr><td rowspan=1 colspan=1>k=1</td><td rowspan=1 colspan=1>k=5</td><td rowspan=1 colspan=1>k=10</td></tr><tr><td rowspan=2 colspan=1>MNIST</td><td rowspan=2 colspan=1>SoftmaxCenter LossIsomax</td><td rowspan=2 colspan=1>98.7598.4498.60</td><td rowspan=1 colspan=1>97.50</td><td rowspan=2 colspan=1>97.8198.2098.63</td><td rowspan=2 colspan=1>97.7398.0598.28</td></tr><tr><td rowspan=1 colspan=1>98.0398.20</td></tr><tr><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>SoftmaxCenter LossIsomax</td><td rowspan=1 colspan=1>90.4590.6190.30</td><td rowspan=1 colspan=1>83.7584.9085.39</td><td rowspan=1 colspan=1>87.4288.0589.14</td><td rowspan=1 colspan=1>87.8988.7589.53</td></tr><tr><td rowspan=1 colspan=1>ILSVRC-sub</td><td rowspan=1 colspan=1>SoftmaxCenter LossIsomax</td><td rowspan=1 colspan=1>75.8975.6075.65</td><td rowspan=1 colspan=1>47.5048.0149.92</td><td rowspan=1 colspan=1>49.5550.7355.68</td><td rowspan=1 colspan=1>52.6353.5757.88</td></tr><tr><td rowspan=2 colspan=1>CASIA-WebFace</td><td rowspan=2 colspan=1>SoftmaxCenter LossIsomax</td><td rowspan=2 colspan=1>85.8785.7685.88</td><td rowspan=1 colspan=1>48.17</td><td rowspan=2 colspan=1>33.9434.2438.23</td><td rowspan=2 colspan=1>28.6028.7334.12</td></tr><tr><td rowspan=1 colspan=1>48.5550.92</td></tr></table>
+
+![](images/719183977c0616448b719dd509e63747fe7f1296d9825ace9a92ce54a2e151c8.jpg)  
+Figure 5: Accuracy curves of CASIA-WebFace testing set. The boost at 32K step is because of the decay of learning rate. (a): Softmax classifier accuracy relative to training steps. (b): $k$ -NN $\scriptstyle ( k = 5 )$ ) classification accuracy.
+
+# 4.3 ADVERSARIAL ROBUSTNESS
+
+In this section, we test the performance of different losses when associated neural networks are attacked by adversarial samples2. To do so, we employ the Fast Gradient Sign Method to generate the adversarial samples Dong et al. (2017), say
+
+$$
+\mathtt { a d v e r s a r i a l } = \mathtt { o r i g i n a l } + \epsilon * \mathrm { s i g n } \big ( \nabla _ { x } J ( x , y ) \big ) ,
+$$
+
+where $\epsilon$ controls the degree of adversary. Small epsilon means slight perturbation and weak attacking. The gradient in the above formula is derived from the derivative of the softmax loss for each of three compared models.
+
+The experiments are performed on MNIST and CAFAR-10. The experimental procedures are kept the same with ones in section 4.2. From the results shown in Table 4, we can see that the isomax loss consistently outperforms the other two losses. It is worthing noting that the superiority of the isomax loss is significant for $\epsilon = 0 . 0 0 3$ on MNIST. The underlying reason is presumably that classes are still maintained separable due to the more compact isotropic distribution for the isomax loss under the slight perturbation whereas the distribution of classes for the softmax and center losses might be
+
+![](images/7eac8e85e050402707f289a8b42d6f43568c070da60cb5e8eea59a9ff449db16.jpg)  
+Figure 6: Values of center loss relative to training steps on different datasets. Two of four datasets are shown here as examples.
+
+<table><tr><td>Methods</td><td>∈=0.003</td><td>∈=0.01</td><td>∈=0.03</td></tr><tr><td>Softmax</td><td>70.12%</td><td>39.84%</td><td>20.93%</td></tr><tr><td>Center Loss</td><td>69.53%</td><td>37.68%</td><td>19.38%</td></tr><tr><td>Isomax Loss</td><td>74.34%</td><td>43.75%</td><td>22.32%</td></tr></table>
+
+(a) MNIST   
+
+<table><tr><td>Methods</td><td>∈=0.003</td><td>∈=0.01</td><td>∈=0.03</td></tr><tr><td>Softmax</td><td>76.43%</td><td>49.28%</td><td>25.39%</td></tr><tr><td>Center Loss</td><td>77.56%</td><td>49.65%</td><td>26.01%</td></tr><tr><td>IsomaxLoss</td><td>85.20%</td><td>54.57%</td><td>27.83%</td></tr></table>
+
+(b) CIFAR-10
+
+Table 4: Classification accuracy on MNIST and CIFAR-10 for adversarial attacking. The adversarial samples are produced with the fast gradient sign method (FGSM) with different .
+
+messy, especially near boundaries. To our surprise, however, the center loss performs the worst on CIFAR-10, implying its weak robustness under adversarial perturbation.
+
+# 4.4 CLUSTERING
+
+Compact intra-class features can be used in clustering tasks. We evaluate K-means and agglomerative clustering (ward linkage) performance of features under different supervision signals. For MNIST, CIFAR-10, and ILSVRC-sub, 10,000 images from their corresponding testing set are used for clustering. As for the face model, we use 12,776 face images of 466 different identities from FRGC Phillips et al. (2005) dataset. For evaluation, 12 pre-trained models mentioned above are employed, i.e. 3 different losses for each of 4 datasets. Normalized Mutual Information (NMI) Strehl & Ghosh (2002) is selected as the clustering performance evaluation metric. The results in Table 5 show the consistent superiority of our algorithm.
+
+# 4.5 FACE VERIFICATION
+
+We also evaluate the performance of our algorithm on a widely used verification benchmark LFW Huang et al. (2008). The dataset contains 13,233 faces from 5749 individuals with different poses and expressions. We use the models trained on 0.32M CASIA-WebFace mentioned above. We also implement a model trained with triplet loss with the same training data and network. There is no overlap between our training data and LFW dataset. We use MTCNN Zhang et al. (2016) to align the face images of LFW like what we do on CASIA-WebFace. Instructed by the protocol for unrestricted with labeled outside data Huang & Learned-Miller (2014), we report the result of verification performance of 6,000 pairs of faces in Table 6 and Figure 7. We only train our model with 0.32M outside face images on a single network, so our purpose is not to improve state-of-the-art accuracy but a good comparison of isomax loss, center loss, softmax loss and triplet loss under the same condition.
+
+Our proposed method is more efficient and suitable in verification task compared with softmax loss baseline and also outperforms center loss and triplet loss under the same condition. Since the dataset we use for training has more than 10,000 classes, making centers for each class difficult to determine in a mini-batch. So the model with center loss surpasses the model with softmax loss by a small margin while ours outperforms it by a relatively large margin. Triplet loss is another baseline we want to compare with. Due to its long training process, we partially plot it in Figure 7. The accuracy of triplet loss finally plateaus at $9 6 . 8 8 \%$ , which is lower than the accuracy reported in the original paper. The small amount of training data and complex training tricks that we do not tune well may be the reasons.
+
+Table 5: Clustering results.   
+
+<table><tr><td rowspan=1 colspan=1>Datasets</td><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=1>K-meansNMI score</td><td rowspan=1 colspan=1>AgglomerativeNMI score</td></tr><tr><td rowspan=1 colspan=1>MNIST</td><td rowspan=1 colspan=1>SoftmaxCenterLossIsomax</td><td rowspan=1 colspan=1>0.90310.92700.9666</td><td rowspan=1 colspan=1>0.91100.90980.9404</td></tr><tr><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>SoftmaxCenter Loss</td><td rowspan=1 colspan=1>0.73660.74280.7837</td><td rowspan=1 colspan=1>0.71360.72430.7541</td></tr><tr><td rowspan=1 colspan=1>ILSVRC-sub</td><td rowspan=1 colspan=1>SoftmaxCenter LossIsomax</td><td rowspan=1 colspan=1>0.71910.71930.7349</td><td rowspan=1 colspan=1>0.76580.77130.7831</td></tr><tr><td rowspan=1 colspan=1>CASIA-WebFace</td><td rowspan=1 colspan=1>SoftmaxCenterLossIsomax</td><td rowspan=1 colspan=1>0.94040.94210.9461</td><td rowspan=1 colspan=1>0.96850.96910.9721</td></tr></table>
+
+Table 6: Verification accuracy on LFW.   
+
+<table><tr><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=1>Networks</td><td rowspan=1 colspan=1>Outside Data</td><td rowspan=1 colspan=1>Acc(%)</td></tr><tr><td rowspan=2 colspan=1>Yi et al. (2014)DeepFace Taigman et al. (2014)FaceNet Schroff et al. (2015)Deep FR Parkhi et al. (2015)DeepID-2+ Sun et al.(2015)</td><td rowspan=2 colspan=1>131125</td><td rowspan=1 colspan=1>0.49 M</td><td rowspan=2 colspan=1>97.7397.3599.6398.9599.47</td></tr><tr><td rowspan=1 colspan=1>4M200M2.6 M1</td></tr><tr><td rowspan=4 colspan=1>Softmax LossCenter LossTriplet LossIsomax Loss</td><td rowspan=2 colspan=1>11</td><td rowspan=1 colspan=1>0.32 M</td><td rowspan=2 colspan=1>97.5097.63</td></tr><tr><td rowspan=1 colspan=1>0.32 M</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.32 M</td><td rowspan=1 colspan=1>96.88</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.32 M</td><td rowspan=1 colspan=1>98.03</td></tr></table>
+
+![](images/44f00d71423a7a0e685a86bb6a7126e09ca227563cfea8755c9a877740a486ce.jpg)  
+Figure 7: LFW verification accuracy during training. (a): Triplet loss converges very slowly. (b): Zooming in the final stage of training shows that our proposed loss achieves better performance.
+
+# 5 CONCLUSION
+
+In this paper, we propose a new isotropic loss together with the original softmax loss named isomax loss. With the joint supervision signal, CNNs generate more isotropic feature distribution for each class, and the Euclidean distance in the class decreases. The 2-D visualization and extensive experiments on different datasets for different tasks show the effectiveness of our approach. Comparison to other related works illustrates the advantage of our method on tasks using feature distance.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. arXiv preprint arXiv:1603.04467, 2016.
+
+Doug Beeferman and Adam Berger. Agglomerative clustering of a search engine query log. In Proceedings of the sixth ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 407–416. ACM, 2000.
+
+Leon Bottou. Large-scale machine learning with stochastic gradient descent. In ´ Proceedings of COMPSTAT’2010, pp. 177–186. Springer, 2010.
+
+Jia Deng, Alex Berg, Sanjeev Satheesh, H Su, Aditya Khosla, and L Fei-Fei. Imagenet large scale visual recognition competition 2012 (ilsvrc2012), 2012.
+
+Yinpeng Dong, Fangzhou Liao, Tianyu Pang, Xiaolin Hu, and Jun Zhu. Discovering adversarial examples with momentum. arXiv preprint arXiv:1710.06081, 2017.
+
+Geoffrey E Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan R Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012.
+
+Gary B Huang and Erik Learned-Miller. Labeled faces in the wild: Updates and new reporting procedures. Dept. Comput. Sci., Univ. Massachusetts Amherst, Amherst, MA, USA, Tech. Rep, pp. 14–003, 2014.
+
+Gary B Huang, Marwan Mattar, Tamara Berg, and Eric Learned-Miller. Labeled faces in the wild: A database forstudying face recognition in unconstrained environments. In Workshop on faces in’Real-Life’Images: detection, alignment, and recognition, 2008.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456, 2015.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Yann LeCun, LD Jackel, Leon Bottou, Corinna Cortes, John S Denker, Harris Drucker, Isabelle ´ Guyon, UA Muller, Eduard Sackinger, Patrice Simard, et al. Learning algorithms for classification: A comparison on handwritten digit recognition. Neural networks: the statistical mechanics perspective, 261:276, 1995.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Weiyang Liu, Yandong Wen, Zhiding Yu, and Meng Yang. Large-margin softmax loss for convolutional neural networks. In ICML, pp. 507–516, 2016.
+
+Omkar M Parkhi, Andrea Vedaldi, Andrew Zisserman, et al. Deep face recognition. In BMVC, volume 1, pp. 6, 2015.
+
+P Jonathon Phillips, Patrick J Flynn, Todd Scruggs, Kevin W Bowyer, Jin Chang, Kevin Hoffman, Joe Marques, Jaesik Min, and William Worek. Overview of the face recognition grand challenge. In Computer vision and pattern recognition, 2005. CVPR 2005. IEEE computer society conference on, volume 1, pp. 947–954. IEEE, 2005.
+
+Ce Qi and Fei Su. Contrastive-center loss for deep neural networks. arXiv preprint arXiv:1707.07391, 2017.
+
+Florian Schroff, Dmitry Kalenichenko, and James Philbin. Facenet: A unified embedding for face recognition and clustering. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 815–823, 2015.
+
+Hidetoshi Shimodaira. Improving predictive inference under covariate shift by weighting the loglikelihood function. Journal of statistical planning and inference, 90(2):227–244, 2000.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+A. Strehl and J. Ghosh. Cluster ensembles — a knowledge reuse framework for combining multiple partitions. Journal of Machine Learning Research, 3:583–617, 2002.
+
+Yi Sun, Yuheng Chen, Xiaogang Wang, and Xiaoou Tang. Deep learning face representation by joint identification-verification. In Advances in neural information processing systems, pp. 1988–1996, 2014.
+
+Yi Sun, Xiaogang Wang, and Xiaoou Tang. Deeply learned face representations are sparse, selective, and robust. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2892–2900, 2015.
+
+Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, and Alexander A Alemi. Inception-v4, inception-resnet and the impact of residual connections on learning. In AAAI, pp. 4278–4284, 2017.
+
+Yaniv Taigman, Ming Yang, Marc’Aurelio Ranzato, and Lior Wolf. Deepface: Closing the gap to human-level performance in face verification. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1701–1708, 2014.
+
+Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural networks for machine learning, 4(2):26– 31, 2012.
+
+Yandong Wen, Kaipeng Zhang, Zhifeng Li, and Yu Qiao. A discriminative feature learning approach for deep face recognition. In European Conference on Computer Vision, pp. 499–515. Springer, 2016.
+
+Dong Yi, Zhen Lei, Shengcai Liao, and Stan Z Li. Learning face representation from scratch. arXiv preprint arXiv:1411.7923, 2014.
+
+Kaipeng Zhang, Zhanpeng Zhang, Zhifeng Li, and Yu Qiao. Joint face detection and alignment using multitask cascaded convolutional networks. IEEE Signal Processing Letters, 23(10):1499–1503, 2016.

parse/train/SyXNErg0W/SyXNErg0W_content_list.json

@@ -0,0 +1,1658 @@
+[
+    {
+        "type": "text",
+        "text": "SOFTMAX SUPERVISION WITH ISOTROPIC NORMALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            591,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            184,
+            170,
+            400,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The softmax function is widely used to train deep neural networks for multi-class classification. Despite its outstanding performance in classification tasks, the features derived from the supervision of softmax are usually sub-optimal in some scenarios where Euclidean distances apply in feature spaces. To address this issue, we propose a new loss, dubbed the isotropic loss, in the sense that the overall distribution of data points is regularized to approach the isotropic normal one. Combined with the vanilla softmax, we formalize a novel criterion called the isotropic softmax, or isomax for short, for supervised learning of deep neural networks. By virtue of the isomax, the intra-class features are penalized by the isotropic loss while inter-class distances are well kept by the original softmax loss. Moreover, the isomax loss does not require any additional modifications to the network, mini-batches or the training process. Extensive experiments on classification and clustering are performed to demonstrate the superiority and robustness of the isomax loss. ",
+        "bbox": [
+            233,
+            265,
+            764,
+            458
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            482,
+            336,
+            498
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent years have witnessed significant progress in image classification tasks with convolution neural networks (CNN) LeCun et al. (1998); Krizhevsky et al. (2012). For classification problems, the softmax is a suitable criterion for supervised learning since it is capable of training network parameters to generate discriminative features for hyperplanes to distinguish different classes. Due to its end-to-end characteristic, CNN is amenable to learning such that we only need to feed the network with plenty of training samples. Therefore, the softmax is the most fundamental classifier applied in architectures of deep learning. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            611
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, there are still defects of the softmax loss1. Features extracted by convolution layers work best only with softmax classifier. When we apply these feature vectors in other tasks such as image retrieval with $k$ -nearest neighbors $k$ -NN) or clustering with K-means, the results are usually suboptimal, as shown in Figure 1. To separate different classes is the sole purpose of softmax classifier, and it does not ensure that the distances (generally Euclidean distances) within the same class are smaller than inter-class ones. In order to extract better features not only for classification powered by the softmax classifier but for other tasks using distances of feature vectors, many approaches have been proposed in the past years. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            729
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One way is adding some new loss terms to the original softmax loss. The center loss Wen et al. (2016) penalizes distances of training samples to their corresponding class centers, thus enhancing the compactness of each class. Since this loss cannot extend the distances between class centers, the result depends heavily on the center initialization of all classes. Also, a relatively small batch size will seriously affect the performance of the algorithm, because centers cannot be accurately calculated with limited examples in a batch, especially for datasets with plenty of classes. The contrastive-center loss Qi & Su (2017) combines the center loss and the contrastive loss Sun et al. (2014) together to penalize distances of samples in the same classes and enlarge inter-class distances. It works well on the CIFAR-10 classification task Krizhevsky & Hinton (2009) and the LFW verification task Huang et al. (2008). To gain good performance, however, this loss needs to carefully select data batches for training too. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/253bc204829d1fdb99e508602a0b3eaffd1da689b739b19dbbb5369767b90d23.jpg",
+        "image_caption": [
+            "Figure 1: (a) Features extracted by CNN with softmax loss are separated well into two classes by a line (hyperplanes in high-dimensional spaces), but lots of orange samples are included in a neighborhood (the blue circle) of a blue sample. (b) The performance of agglomerative clustering Beeferman & Berger (2000) on these features is poor. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            93,
+            787,
+            179
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Some other strategies aim at solving the problem in a different way. The triplet loss Schroff et al. (2015) comes up with a novel method. Instead of exploiting the softmax loss, they remove the final logits layer of network and directly minimize Euclidean distances between anchors and positive samples while maximizing distances of anchors to negative samples in triplets. However, the number of different triplets are much more than that of training samples, leading to that selecting proper triplets is crucial for the triplet loss. Or inappropriate triplets will result in slow convergence. What’s more, the scalar margin in the triplet loss and the learning strategy influence the final performance of the model as well. To sum up, the principle of the triplet loss is straightforward and plausible, but the parameters and the “semi-hard triplets mining” approach make this algorithm hard to implement. ",
+        "bbox": [
+            174,
+            265,
+            825,
+            390
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Methods mentioned above are all based on supervised optimization, meaning that they all depend on sample labels to learn discriminative features. In this paper, we propose a simple approach, named isotropic normalization, that reshapes data distribution towards easy classification without the aid of labels. We firstly analyze the distribution of features extracted by CNNs supervised by the softmax loss. Elliptical shapes of feature distributions lead to intra-class distances even greater than inter-class distances, indicating that the softmax loss needs to be improved for tasks using feature distances. Then we attempt to modify the feature distribution according to the global distribution itself rather than information from sample labels. Combined with the vanilla softmax, we propose a new loss, called the isotropic softmax (isomax for short) loss. For the isomax, the intra-class distances of the features can be well minimized by the isotropic loss, and at the same time, the vanilla softmax loss ensures the inter-class separability. We perform extensive experiments with different networks and different datasets to illustrate the effectiveness, simplicity and portability of our method. ",
+        "bbox": [
+            174,
+            397,
+            825,
+            577
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 ANALYSIS OF SOFTMAX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            597,
+            406,
+            613
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce the softmax loss and analyze its limitations with visualization of 2- D features. According to the feature distribution, we show why these features are not the optimal option in tasks that use feature distances. Then we present our approach to ameliorating the feature distribution. ",
+        "bbox": [
+            174,
+            627,
+            825,
+            684
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 SOFTMAX LOSS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            700,
+            326,
+            714
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Suppose that we have $N$ training samples of $n$ classes. Let $x _ { i } \\in \\mathbb { R } ^ { d }$ denote the $i$ -th image feature vector and $y _ { i }$ its label. Then softmax loss can be formulated as ",
+        "bbox": [
+            174,
+            726,
+            821,
+            753
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d908ecfa381c724d7c05e702b86769c28c9a13cf468f94eb58a53a98f684b16e.jpg",
+        "text": "$$\n\\mathcal { L } _ { S } = \\sum _ { i = 1 } ^ { N } - \\log \\left( \\frac { \\exp ( f _ { y _ { i } } ) } { \\sum _ { j = 1 } ^ { n } \\exp ( f _ { j } ) } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            756,
+            620,
+            800
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For typical neural networks, $f$ denotes the output of a fully connected layer with weights $W$ (a parameter matrix with $n$ columns) and bias $b$ . Then the softmax loss can be rewritten as Equation 2 Liu et al. (2016) ",
+        "bbox": [
+            176,
+            801,
+            821,
+            842
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f7af9715438ced55c97bf448a6ffd45a29da39a701aa2dadafee53c612487c7.jpg",
+        "text": "$$\n\\begin{array} { r l r } {  { \\mathcal L _ { S } = - \\sum _ { i = 1 } ^ { N } \\log \\frac { \\exp ( W _ { y _ { i } } ^ { T } x _ { i } + b _ { y _ { i } } ) } { \\sum _ { j = 1 } ^ { n } \\exp ( W _ { j } ^ { T } x _ { i } + b _ { j } ) } } } \\\\ & { } & { = - \\sum _ { i = 1 } ^ { N } \\log \\frac { \\exp ( \\| W _ { y _ { i } } \\| \\| x _ { i } \\| \\cos ( \\theta _ { y _ { i } } ) + b _ { y _ { i } } ) } { \\sum _ { j = 1 } ^ { n } \\exp ( \\| W _ { j } \\| \\| x _ { i } \\| \\cos ( \\theta _ { j } ) + b _ { j } ) } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            840,
+            668,
+            930
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/7a1fc78915df369ef62c973ae7ec851b4edcff4a9f0f54065f5e6faf474aadfe.jpg",
+        "image_caption": [
+            "Figure 2: Visualization of MNIST. (a) Features of 1000 MNIST samples obtained with softmax loss. Different colors represent different classes. (b) Normalize 2-D features to a circle. Best viewed in color. (c) Schematic illustration of our method. We enforce a restriction on features in the approximately orthogonal direction from that of softmax to reshape the feature distribution. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            212,
+            98,
+            782,
+            231
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/a319c52bb042900b0cf828315d0101453ac63ac6deedc5f6cc7bac30ef62f91d.jpg",
+        "table_caption": [
+            "Table 1: The structure of our network for the experiment of MNIST. It is similar to LeNet LeCun et al. (1998), but we add some filters and reduce the number of neurons in the last hidden layer to 2. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Layer</td><td rowspan=1 colspan=1>input</td><td rowspan=1 colspan=1>output</td><td rowspan=1 colspan=1>kernel</td><td rowspan=1 colspan=1>param</td></tr><tr><td rowspan=1 colspan=1>conv1</td><td rowspan=1 colspan=1>28×28×3</td><td rowspan=1 colspan=1>28×28×32</td><td rowspan=1 colspan=1>5×5,1</td><td rowspan=1 colspan=1>2.4K</td></tr><tr><td rowspan=1 colspan=1>pool1</td><td rowspan=1 colspan=1>28×28×32</td><td rowspan=1 colspan=1>14×14×32</td><td rowspan=1 colspan=1>2×2,2</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>conv2</td><td rowspan=1 colspan=1>14×14×32</td><td rowspan=1 colspan=1>14×14×64</td><td rowspan=1 colspan=1>5×5,1</td><td rowspan=1 colspan=1>51.2K</td></tr><tr><td rowspan=1 colspan=1>pool2</td><td rowspan=1 colspan=1>14×14x64</td><td rowspan=1 colspan=1>7×7×64</td><td rowspan=1 colspan=1>2×2,2</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>fc1</td><td rowspan=1 colspan=1>3136</td><td rowspan=1 colspan=1>1024</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3.2M</td></tr><tr><td rowspan=1 colspan=1>drop</td><td rowspan=1 colspan=1>1024</td><td rowspan=1 colspan=1>1024</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>fc2</td><td rowspan=1 colspan=1>1024</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2K</td></tr></table>",
+        "bbox": [
+            326,
+            310,
+            671,
+            417
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { j }$ denotes the $j$ -th column of $W$ . Since $W _ { j }$ and $x _ { i }$ are all vectors, the inner product of them can be formulated as $\\| W _ { j } \\| \\| x _ { i } \\| \\cos ( \\theta _ { j } )$ , where $\\bar { \\theta _ { j } }$ is the angle of $W _ { j }$ and $x _ { i }$ . After formulating the softmax loss to an inner product form with a factor $\\cos ( \\theta )$ , it is clear that the softmax classifier is prone to enforce examples in a class have similar $\\theta$ and different $\\theta$ for different classes. This property of the softmax leads to the thin elliptical shape of feature distribution for each class with respect to the global center. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            564
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 VISUALIZATION ON MNIST ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            584,
+            408,
+            598
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To analyze the feature distribution, it is a feasible way to visualize data points in a 2-D plane or 3-D space. MNIST LeCun et al. (1995) is a hand-written digit dataset of 0-9 in 10 classes, with 60,000 training samples and 10,000 testing samples. Image size of both subsets is $2 8 \\times 2 8$ . Since MNIST is such a simple dataset that even we reduce the dimension of feature vectors to 2, the softmax classifier is applicable to maintain $98 \\%$ accuracy. So we choose it as our first example to describe the feature distribution. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            694
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The network architecture is presented in Table 1. We train the network with 60,000 training samples without data argumentation, and randomly sample 1000 testing images in 10,000 testing set. Since the dimension of feature vectors is 2, we can plot features of testing samples, as shown in Figure 2 (a). It is evident that minimizing the softmax loss leads to the separability of different classes. But for some samples, especially those near to the center of overall distribution, inter-class distances are even smaller than intra-class distances. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            785
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 RESTRICTION TO FEATURE DISTRIBUTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            805,
+            509,
+            820
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 (a) directly shows overall distribution under supervision of softmax loss. The thin shape of feature distribution of a certain class is the inevitable result of the softmax loss according to our previous analysis, which causes the large intra-class distances and small inter-class distances. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Apart from the softmax loss, if we can find a new “force” which can reshape the thin distribution to a “medium build” (Figure 2 (c)) , the inter-class distances will be kept by the softmax loss while the intra-class distances will be guaranteed by the new force. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For a certain class $i$ , we can regard features of this class as a normal distribution $\\textstyle { \\mathcal { N } } ( \\mu _ { i } , \\Sigma _ { i } )$ where $\\mu _ { i }$ is the mean of this class and $\\Sigma _ { i }$ is the covariance matrix. Then there exits an orthogonal matrix $U$ and an eigenvalue-diagonal matrix $D$ satisfying $\\Sigma _ { i } = U D U ^ { \\top }$ . Diagonal values in $D$ can describe the shape of the normal distribution. If these eigenvalues are almost the same (with small variance), then the distribution of features is like an isotropic normal one. This analysis inspires us to devise a simple algorithm to optimize the shape of each class. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 ISOTROPIC SOFTMAX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            208,
+            385,
+            224
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe our approach in detail. The relevant classification criteria are discussed as well. ",
+        "bbox": [
+            171,
+            239,
+            825,
+            268
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 OUR APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            285,
+            330,
+            300
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Inspired by Figure 2 (c) and the discussion of isotropic multivariate normal distribution, the spatial distribution of each class will be more compact if we penalize features such that $\\mathcal { N } ( \\mu _ { i } , \\Sigma _ { i } )$ of class $i$ will be like an isotropic one, say that the variances of different dimensions are approximately uniform. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            367
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 ISOTROPIC SOFTMAX LOSS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            383,
+            418,
+            398
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here we present the isotropic loss that action on data points with the complementary effect compared with the softmax function, writing that ",
+        "bbox": [
+            174,
+            409,
+            823,
+            438
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d2c5f80ac31c734a2f14c838b758e35bf8bbb145cf7e955cad6fcbb36881960.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\mathcal { L } _ { I } = \\frac { 1 } { N - 1 } \\sum _ { i = 1 } ^ { N } ( \\mathcal { D } _ { i } - \\bar { \\mathcal { D } } ) ^ { 2 } } \\\\ { \\displaystyle \\quad = \\frac { 1 } { N - 1 } \\sum _ { i = 1 } ^ { N } \\bigg ( \\| x _ { i } - \\bar { x } \\| _ { 2 } ^ { 2 } - \\frac { \\sum _ { i = 1 } ^ { N } \\| x _ { i } - \\bar { x } \\| _ { 2 } ^ { 2 } } { N } \\bigg ) ^ { 2 } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            443,
+            671,
+            534
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\bar { x }$ denotes the center of $x _ { i }$ , i.e. $\\begin{array} { r } { \\bar { x } = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } x _ { i } } \\end{array}$ . In Equation 3, $\\mathcal { L } _ { I }$ denotes our new isotropic $\\| x _ { i } - \\bar { x } \\| _ { 2 } ^ { 2 }$ . Specially, take $d { = } 2$ in Figure 2 for instance. The $\\mathcal { L } _ { I }$ loss will push points near to the circle of radius $\\bar { \\mathcal D }$ and $\\bar { x }$ for the circle center. ",
+        "bbox": [
+            174,
+            539,
+            826,
+            598
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It is worth mentioning that this method is essentially different from feature normalization after training. We perform this isotropic regularizer during training and $\\bar { \\mathcal D }$ varies, meaning that the shape of each class will be deformed with softmax supervision and isotropic regularization towards easy classification during iterations. ",
+        "bbox": [
+            173,
+            603,
+            825,
+            660
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Obviously, it is impractical and inefficient to calculate the $\\mathcal { L } _ { I }$ loss function for all training examples in each iteration. However, we can compute the estimates of $\\bar { x }$ and $\\bar { \\mathcal D }$ within a batch if we randomly select samples in a training batch. The randomness of the data and the globality of the loss function guarantee the plausibility of such manipulation. Thanks to the decoupling of the isotropic loss and class labels, our loss remains unchanged from the whole training set to a batch. Details are shown in Algorithm 1. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            751
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/6fe7a75c24a99932abb0a457dc4a4eb8253c5ac35db814000d2ff6c06a4bbddc.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Algorithm1Isotropic Normalization ina Mini-Batch</td></tr><tr><td colspan=\"2\">Input: A batch of feature B={x1,.., xm} produced by deep neural networks</td></tr><tr><td>Output:isotropic loss L for a mini-batch 11m</td><td></td></tr><tr><td>xB← m≥i=1xi fori=1...m do</td><td>//calculate the distribution center //calculate the distance to the center</td></tr><tr><td>Di←|xi-xBll2 end for DB↑ 1 m Di m</td><td>//calculate the mean distance</td></tr></table>",
+        "bbox": [
+            176,
+            767,
+            821,
+            921
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/c67225d35b1c4abce577b177f827228d04742ceb68e8ce4390a740653bce776b.jpg",
+        "image_caption": [
+            "Figure 3: Feature distribution of MNIST. 10 different colors represent 10 different classes of digits 0-9. (a) and (b) Combination of isotropic loss and softmax loss with relatively small $\\alpha$ supervise the network to extract better features. (c) Isotropic loss dominates the training and softmax loss loses its role due to a large $\\alpha$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            112,
+            795,
+            223
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The total joint loss named the isotropic softmax (isomax) loss is formulated as ",
+        "bbox": [
+            173,
+            313,
+            687,
+            328
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f3961ea12af925ec662f3e1c756bba717f290b88940283d57a8b7b839b731682.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } = \\mathcal { L } _ { S } + \\alpha \\mathcal { L } _ { I } } \\\\ & { \\quad = - \\displaystyle \\sum _ { i = 1 } ^ { m } \\log \\frac { \\exp ( W _ { y _ { i } } ^ { T } x _ { i } + b _ { y _ { i } } ) } { \\sum _ { j = 1 } ^ { n } \\exp ( W _ { j } ^ { T } x _ { i } + b _ { j } ) } + \\alpha \\frac { \\sum _ { i = 1 } ^ { m } ( \\mathcal { D } _ { i } - \\bar { D } _ { B } ) ^ { 2 } } { m - 1 } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            335,
+            694,
+            392
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { L } _ { S }$ is the softmax loss and $\\alpha$ controls the trade-off between the isotropic loss and the softmax loss. A small $\\alpha$ may be not enough to form an isotropic distribution while a large $\\alpha$ will restrain the supervision of the softmax loss, making features indistinguishable near the hypersphere. In the following section, we will discuss the influence of different $\\alpha$ . ",
+        "bbox": [
+            173,
+            398,
+            825,
+            455
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As mentioned above, the loss is the unbiased variance estimate of distance $\\lVert x _ { i } - \\bar { x } \\rVert _ { 2 } ^ { 2 }$ , which is differentiable to $x _ { i }$ , and $x _ { i }$ is the output of the last hidden layer of CNNs. According to chain rule, our loss term is differentiable to parameters of networks. SGD Bottou (2010), Adam Kingma & Ba (2014), RMSProp Tieleman & Hinton (2012) or other learning methods for neural networks can be used to minimize the isomax loss. As an unsupervised loss term, the optimization of the isotropic loss requires no conditions about training batches or class labels. All we need to do is combining this new loss with the original softmax loss and training the network directly via backpropagation. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            559
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 BALANCE OF TWO LOSS TERMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            577,
+            452,
+            590
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To find out the hyper-parameter $\\alpha$ , we first examine the 2-D distribution of MNIST. After 20,000 step training, the feature distribution of 1,000 test samples are shown in Figure 3. We can see that the result is much like what we expect when $\\alpha { = } 0 . 0 0 5$ or $\\alpha { = } 0 . 0 5$ . But for a large $\\alpha$ , the force of the isotropic loss is so powerful that the softmax loss loses its ability to shape classes. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            659
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "During training, we find that even very small $\\alpha$ is able to cut down the isotropic loss quickly, the only influence of $\\alpha$ is the speed of convergence. But if $\\alpha > 0 . 1$ , not only the training procedure converges slowly, but the result is also unacceptable. This threshold is suitable for almost all networks and datasets we try. In following sections, unless otherwise specified, the value of $\\alpha$ is set to 0.05. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            720
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1.3 COMPARISON WITH FEATURE NORMALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            738,
+            558,
+            752
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since our loss tends to normalize features to a hypersphere surface, one alternative way may be simply normalizing features to a hypersphere, specifically a circle for 2-D features (Figure 2 (b)). It needs no additional operation or loss term during training and may work well in low dimensions, but it does not mean that feature normalization will work in higher dimensions. The reason is that in high-dimensional space, the hyperplanes of the softmax classifier is much more complex. If we normalize the features to a hypersphere after training, many features from different classes would overlap together on the hyperspherical surface. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In fact, isotropic loss, as a part of isomax loss, is not a normalization operation. It only tries to gather the feature points around the sphere surface, which is a slow process. So features cannot be directly stacked together. Moreover, even if features from different classes become close to each other around the sphere surface, softmax loss, as a another supervision in isomax loss, is capable of ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/074a1403077c8bfb53919da9096e162d27e9b537c84e8d12135181dd8aebb960.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=1>Steps to converge</td><td rowspan=1 colspan=1>Label Info.</td><td rowspan=1 colspan=1>Accuracy Var.</td><td rowspan=1 colspan=1>TrainingTricks</td></tr><tr><td rowspan=1 colspan=1>CenterLoss</td><td rowspan=1 colspan=1>35K steps</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>±0.5%</td><td rowspan=1 colspan=1>Batch selection. Center initialization.</td></tr><tr><td rowspan=1 colspan=1>Triplet Loss</td><td rowspan=1 colspan=1>100K+ steps</td><td rowspan=1 colspan=1>Yes</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>Triplet mining. Optimization method.</td></tr><tr><td rowspan=1 colspan=1>Isotropic Loss</td><td rowspan=1 colspan=1>20K steps</td><td rowspan=1 colspan=1>No</td><td rowspan=1 colspan=1>±0.2%</td><td rowspan=1 colspan=1>No tricks.</td></tr></table>",
+        "bbox": [
+            173,
+            102,
+            833,
+            156
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Comparison of three methods. We train these three methods for several trials on MNIST. We can see that our method converges more quickly and are more stable. Training tricks are also summarized. Fluctuation of accuracy on testing set is a measure of algorithm stability and replicability. Here only the fluctuation on softmax classification is compared (triplet loss does not have a softmax classifier). More details of performance can be found in the Experiment section. ",
+        "bbox": [
+            173,
+            162,
+            826,
+            233
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/d5f7976157cb4a6ae4ef741fc502e94566b4fc59b5c7a1c92e901d115384a22b.jpg",
+        "image_caption": [
+            "Figure 4: Illustrative comparison of isomax loss and center loss. When we retrain networks with isomax loss, the overall distribution of test samples is robust and stable. For center loss, different training batches form different centers, and finally result in different global distributions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            262,
+            812,
+            356
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "pushing different feature points away again. Therefore our method is totally different from feature normalization after training. ",
+        "bbox": [
+            174,
+            436,
+            823,
+            467
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 COMPARISON WITH OTHER WORKS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            488,
+            462,
+            503
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "There are some related works with the same purpose as ours such as the triplet loss Schroff et al. (2015) and the center loss Wen et al. (2016). We will analyze the properties of compared methods in this section. Table 2 concisely shows the merits of each method. We also discuss Batch Normalization Ioffe & Szegedy (2015) since it is an operation on feature distributions too, though for different purpose. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            588
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 CENTER LOSS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            608,
+            328,
+            623
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Center loss is an excellent work to solve the problem of large intra-class distances. Jointly supervised by the center loss and the softmax loss, the features of same class can gather together. Equation 5 gives the formulation ",
+        "bbox": [
+            174,
+            636,
+            825,
+            678
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cf2bc22f4b3500d010a3d8da54245a47b1cf177869c8a297fe00d9f19499483b.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\mathcal { L } = \\mathcal { L } _ { S } + \\alpha \\mathcal { L } _ { C } } \\\\ { \\displaystyle \\quad = - \\sum _ { i = 1 } ^ { m } \\log \\frac { \\exp ( W _ { y _ { i } } ^ { T } x _ { i } + b _ { y _ { i } } ) } { \\sum _ { j = 1 } ^ { n } \\exp ( W _ { i } ^ { T } x _ { i } + b _ { i } ) } + \\frac { \\lambda } { 2 } \\sum _ { i = 1 } ^ { m } \\| x _ { i } - c _ { y _ { i } } \\| _ { 2 } ^ { 2 } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            690,
+            687,
+            747
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $c _ { y _ { i } }$ is the center of the $i$ -th sample class in a batch. Centers are learned in each iteration and each batch. Though the authors of this work give some methods to avoid perturbations of centers, centers are still difficult to determine, especially when the samples from one class are limited in a batch. We train models of MNIST with the center loss and the isomax loss both twice and the experimental conditions are all the same except for the different loss terms. Results are shown in Figure 4. It is obvious that once a center is not well established, the features of this class will gather near this center, incurring that the overall distribution of associated features is unfavorable for classification. Instead the results of our isomax loss are more stable and robust. What’s more, the fluctuating convergence and the additional calculation of centers make the training time longer. In our algorithm, the isotropic loss is an unsupervised loss. This loss function learns a better distribution directly from distribution itself without using labels of training data. All we need is randomly selecting samples from the training set like what we do with the softmax loss. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2.2 TRIPLET LOSS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            330,
+            118
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The triplet loss is employed to supervise the learning of an Euclidean embedding per image. The loss is formulated as ",
+        "bbox": [
+            176,
+            127,
+            823,
+            156
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5d3a180777ee89bc777269c0296789f765e3067e5ee95a641af2f51741a82338.jpg",
+        "text": "$$\n\\sum _ { i } ^ { N } [ \\| f ( x _ { i } ^ { a } ) - f ( x _ { i } ^ { p } ) \\| _ { 2 } ^ { 2 } - \\| f ( x _ { i } ^ { a } ) - f ( x _ { i } ^ { n } ) \\| + \\alpha ] _ { + }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            159,
+            666,
+            202
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $f ( x )$ is an embedding generated by CNNs, the selected anchor $\\boldsymbol { x } _ { i } ^ { a }$ , the positive sample $x _ { i } ^ { p }$ , and the negative sample $\\boldsymbol { x } _ { i } ^ { n }$ constitute a triplet. The triplet loss directly minimizes the Euclidean distance of samples from the same class and maximizes the distance of samples from the different class until reaching a selection margin $\\alpha$ . ",
+        "bbox": [
+            174,
+            208,
+            823,
+            263
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the triplet loss, the learning strategy and the triplet selection are critical for performance. By many practices, we find that the model is sensitive to the learning rate and the learning method. Also, the converging speed is much lower than that of the model supervised by the softmax loss. Due to the massive combination of triplets and the learning tricks it requires, the results we get are not so good. To sum up, the training with the triplet loss is a laborious task. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            342
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2.3 BATCH NORMALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            356,
+            401,
+            369
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Batch Normalization is a method to reduce internal covariate shift in data Shimodaira (2000). They introduce feature $\\boldsymbol { x } \\mathbf { = } ( x ^ { ( 1 ) } , . . . , x ^ { ( k ) } , . . . , x ^ { ( d ) } )$ $\\gamma ^ { ( k ) }$ and $\\beta ^ { ( k ) }$ for each activation to a new feature $x ^ { ( k ) }$ in a $\\boldsymbol { y } { = } ( y ^ { ( 1 ) } , { \\ldots } , y ^ { ( k ) } , { \\ldots } , y ^ { ( d ) } )$ $d$ -dimensional feature $x$ , and transform original by ",
+        "bbox": [
+            174,
+            380,
+            825,
+            426
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e42a79cd0f37cda142675d2ef283b68715234671966073bd83755d37f5b7e47f.jpg",
+        "text": "$$\ny ^ { ( k ) } = \\gamma ^ { ( k ) } \\frac { x ^ { ( k ) } - \\mathrm { E } [ x ^ { ( k ) } ] } { \\sqrt { \\mathrm { V a r } [ x ^ { ( k ) } ] } } + \\beta ^ { ( k ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            441,
+            614,
+            479
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "By adding Batch-Norm layer (BN layer) to a certain layer in networks, each dimension of the feature of this layer is transformed according to Equation 7. Training samples in a batch are used for feature distribution transformation, which seems similar to our approach. ",
+        "bbox": [
+            174,
+            481,
+            825,
+            523
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Though batch normalization and our method both aim at distribution transformation, they are totally different from operation and functionality. According to Equation 7, the normalization operation is along the axis of one dimension of features. Batch normalization constrains the values of each dimension of features within a reasonable range, while our method normalizes Euclidean distances of feature vectors with respect to the global center of data distribution. To make it clearer, we interpret a simplified example by letting $\\gamma ^ { ( k ) } { = } 1$ and $\\beta ^ { ( k ) } { = } 0$ . As each dimension is normalized, batch normalization transforms features inside a hypersphere. Our loss term tries to push features onto the spherical surface, thus reducing the variance of distances to the distribution center (spherical center). Batch normalization prevents the training from getting stuck. As for our approach, a final feature map with small intra-class distance and large inter-class distance is our target. In fact, these two seemingly similar operations are mutually independent. If we use batch normalization for the last hidden layer, the $x$ in Algorithm 1 will be replaced by the output $y$ of batch normalization. In the following experiments in the next section, batch normalization is applied together with our new loss. ",
+        "bbox": [
+            174,
+            530,
+            825,
+            726
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Briefly in summary, batch normalization is a local normalization on a certain feature map to improve the training of the network. Ours is a global geometric supervision on the overall feature distribution of the last hidden layer to acquire better representations. ",
+        "bbox": [
+            174,
+            732,
+            823,
+            775
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            795,
+            326,
+            810
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the isomax on three tasks: image classification, feature clustering and face verification. Experiments are performed on four datasets: MNIST, CIFAR-10, a subset of ILSVRC2012 Deng et al. (2012) with 200 classes, and CASIA-WebFace Yi et al. (2014). We divide CASIA-WebFace into training and testing sets with a ratio of 2:1. These four datasets are very different in data attributes, data volumes, and class numbers. For the classification task, the testing sets of these four datasets are all used. For the clustering task, the Face Recognition Grand Challenge (FRGC) Phillips et al. (2005) dataset is also used for testing. For face verification, we use the Labeled Faces in the ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Wild (LFW) benchmark dataset. To compare fairly for each dataset, we train three models under different supervision: the softmax loss, the center-softmax joint loss and our isomax loss using the same training methodology and network architecture. For verification task, we also train a model with the triplet loss since it achieves state-of-the-art performance in LFW. All the experiments are implemented with TensorFlow Abadi et al. (2016). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENT SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            190,
+            382,
+            205
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 MNIST AND CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            217,
+            398,
+            232
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For MNIST, the network we use is shown in Table 1. For CIFAR-10, inspired by the architecture of VGG-net Simonyan & Zisserman (2014), we design our network in this way: 3 cascaded convolution blocks followed by a dropout Hinton et al. (2012) layer and then a fully-connected layer . There are 4 cascaded convolution layers with size of $3 \\times 3$ (stride ${ \\mathop : } = 1$ ) and a max-pooling layer with size of $2 \\times 2$ (stride $^ { = 2 }$ ) in each block. Filter numbers in blocks are 64, 96 and 128. We do not use data augmentation on these two datasets but use a dropout of 0.8. The initial learning rate is 0.1 and decays with an exponential rate of 0.96 every 1000 steps. The Adagrad method is employed for optimization. Batch size is 128. ",
+        "bbox": [
+            174,
+            241,
+            825,
+            353
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1.2 ILSVRC-SUB ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            368,
+            325,
+            382
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For this dataset, there are 200 classes and about 1300 images in each class. The Inception-ResNetv1 network Szegedy et al. (2017) is applied. We do not use the input size of $2 9 9 \\times 2 9 9$ according to the original paper, but $1 6 0 \\times 1 6 0$ for simplicity of calculation. In training phase, we resize the short edge of image to 182, and randomly crop a $1 6 0 \\times 1 6 0$ window. The random adjustment of hue, brightness, contrast and saturation is applied. In testing phase, we resize the short edge to 160 and crop a square sub-image in the center. We harness Adagrad and a decaying learning rate that starts at 0.05 and decays with an exponential rate of 0.94 every two epochs. Batch size is 128. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            491
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1.3 CASIA-WEBFACE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            506,
+            357,
+            521
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "CASIA-WebFace contains $0 . 4 9 \\mathbf { M }$ labeled face images from over 10,575 individuals. We firstly exploit MTCNN Zhang et al. (2016) to align face images based on 5 points. Then two-thirds of images from each individual (about 0.32M totally) are randomly selected to train the InceptionResNet-v1 network. During training, we resize images to $1 8 2 \\times 1 8 2$ and randomly crop a $1 6 0 \\times 1 6 0$ window, while for testing we directly resize images to $1 6 0 \\times 1 6 0$ . Random left-to-right flipping is also used for training. The training method we use is RMSProp with decay of 0.9 and $\\epsilon = 1 . 0$ . Batch size is 512. In fact, this relatively large batch size is chosen for center loss since centers need to be updated in a batch and the number of classes of CASIA dataset is too large. We use an initial learning rate of 0.1, divided by 10 after 50 epochs and 65 epochs. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            656
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            674,
+            331,
+            688
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The softmax loss is our baseline, which is designed for image classification. So we firstly evaluate our model on this kind of task. To ensure that our modification to the original softmax loss has no negative impact on the softmax classifier, we firstly evaluate the accuracy on four datasets. Then, to illustrate the superiority of our model in distance-based tasks, we also report the $k$ -NN classification results using feature vectors attained by the supervision of compared losses. Table 3 shows the experimental results. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            784
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We observe that our algorithm does not deteriorate the performance of the softmax classifier, while in $k$ -NN classification tasks, our proposed algorithm performs better, especially for datasets with many classes. For these datasets, it is more essential to place features of different classes in a finite feature space properly. To show details of training, we take the CASIA-WebFace dataset as an example, plotting the curve of accuracy during training process in Figure 5. ",
+        "bbox": [
+            174,
+            791,
+            823,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Another interesting evaluation we analyze here is shown in Figure 6. In three contrast experiments, we monitor the value of center loss, which is only minimized as a loss term in the experiment of center loss. However, for each dataset, the isomax loss makes the center loss much lower, though we do not take the initiative to optimize it. As the center loss is a measure of intra-class distance, this proves that, by reshaping the overall global distribution, our algorithm can reduce the distance within a class more effectively. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/114f61570604ab24369b0ae983c085989813ddf20c8a7a0b971341ebdfcab376.jpg",
+        "table_caption": [
+            "Table 3: Classification results. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Datasets</td><td rowspan=2 colspan=1>Methods</td><td rowspan=2 colspan=1>SoftmaxAcc (%)</td><td rowspan=1 colspan=3>k-NN Acc (%)</td></tr><tr><td rowspan=1 colspan=1>k=1</td><td rowspan=1 colspan=1>k=5</td><td rowspan=1 colspan=1>k=10</td></tr><tr><td rowspan=2 colspan=1>MNIST</td><td rowspan=2 colspan=1>SoftmaxCenter LossIsomax</td><td rowspan=2 colspan=1>98.7598.4498.60</td><td rowspan=1 colspan=1>97.50</td><td rowspan=2 colspan=1>97.8198.2098.63</td><td rowspan=2 colspan=1>97.7398.0598.28</td></tr><tr><td rowspan=1 colspan=1>98.0398.20</td></tr><tr><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>SoftmaxCenter LossIsomax</td><td rowspan=1 colspan=1>90.4590.6190.30</td><td rowspan=1 colspan=1>83.7584.9085.39</td><td rowspan=1 colspan=1>87.4288.0589.14</td><td rowspan=1 colspan=1>87.8988.7589.53</td></tr><tr><td rowspan=1 colspan=1>ILSVRC-sub</td><td rowspan=1 colspan=1>SoftmaxCenter LossIsomax</td><td rowspan=1 colspan=1>75.8975.6075.65</td><td rowspan=1 colspan=1>47.5048.0149.92</td><td rowspan=1 colspan=1>49.5550.7355.68</td><td rowspan=1 colspan=1>52.6353.5757.88</td></tr><tr><td rowspan=2 colspan=1>CASIA-WebFace</td><td rowspan=2 colspan=1>SoftmaxCenter LossIsomax</td><td rowspan=2 colspan=1>85.8785.7685.88</td><td rowspan=1 colspan=1>48.17</td><td rowspan=2 colspan=1>33.9434.2438.23</td><td rowspan=2 colspan=1>28.6028.7334.12</td></tr><tr><td rowspan=1 colspan=1>48.5550.92</td></tr></table>",
+        "bbox": [
+            259,
+            101,
+            738,
+            299
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/719183977c0616448b719dd509e63747fe7f1296d9825ace9a92ce54a2e151c8.jpg",
+        "image_caption": [
+            "Figure 5: Accuracy curves of CASIA-WebFace testing set. The boost at 32K step is because of the decay of learning rate. (a): Softmax classifier accuracy relative to training steps. (b): $k$ -NN $\\scriptstyle ( k = 5 )$ ) classification accuracy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            340,
+            790,
+            530
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            606,
+            821,
+            636
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 ADVERSARIAL ROBUSTNESS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            652,
+            413,
+            666
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this section, we test the performance of different losses when associated neural networks are attacked by adversarial samples2. To do so, we employ the Fast Gradient Sign Method to generate the adversarial samples Dong et al. (2017), say ",
+        "bbox": [
+            174,
+            679,
+            823,
+            722
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e939a8726659ef0d48003132979fb51859c47cb284985940ac5d96e8d7a859a9.jpg",
+        "text": "$$\n\\mathtt { a d v e r s a r i a l } = \\mathtt { o r i g i n a l } + \\epsilon * \\mathrm { s i g n } \\big ( \\nabla _ { x } J ( x , y ) \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            728,
+            650,
+            746
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "where $\\epsilon$ controls the degree of adversary. Small epsilon means slight perturbation and weak attacking. The gradient in the above formula is derived from the derivative of the softmax loss for each of three compared models. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            795
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The experiments are performed on MNIST and CAFAR-10. The experimental procedures are kept the same with ones in section 4.2. From the results shown in Table 4, we can see that the isomax loss consistently outperforms the other two losses. It is worthing noting that the superiority of the isomax loss is significant for $\\epsilon = 0 . 0 0 3$ on MNIST. The underlying reason is presumably that classes are still maintained separable due to the more compact isotropic distribution for the isomax loss under the slight perturbation whereas the distribution of classes for the softmax and center losses might be ",
+        "bbox": [
+            173,
+            801,
+            825,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/7eac8e85e050402707f289a8b42d6f43568c070da60cb5e8eea59a9ff449db16.jpg",
+        "image_caption": [
+            "Figure 6: Values of center loss relative to training steps on different datasets. Two of four datasets are shown here as examples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            111,
+            794,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/c01a67d8f290cdbe117532860db7b77146df60315b1959583605ee0a6592f16e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>∈=0.003</td><td>∈=0.01</td><td>∈=0.03</td></tr><tr><td>Softmax</td><td>70.12%</td><td>39.84%</td><td>20.93%</td></tr><tr><td>Center Loss</td><td>69.53%</td><td>37.68%</td><td>19.38%</td></tr><tr><td>Isomax Loss</td><td>74.34%</td><td>43.75%</td><td>22.32%</td></tr></table>",
+        "bbox": [
+            526,
+            357,
+            821,
+            412
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/073ac5851d0e437e64527b89823e6e4feb30631013e51584eb1cffa3fe469c3a.jpg",
+        "table_caption": [
+            "(a) MNIST "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>∈=0.003</td><td>∈=0.01</td><td>∈=0.03</td></tr><tr><td>Softmax</td><td>76.43%</td><td>49.28%</td><td>25.39%</td></tr><tr><td>Center Loss</td><td>77.56%</td><td>49.65%</td><td>26.01%</td></tr><tr><td>IsomaxLoss</td><td>85.20%</td><td>54.57%</td><td>27.83%</td></tr></table>",
+        "bbox": [
+            173,
+            357,
+            470,
+            412
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "(b) CIFAR-10 ",
+        "bbox": [
+            630,
+            422,
+            717,
+            435
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Classification accuracy on MNIST and CIFAR-10 for adversarial attacking. The adversarial samples are produced with the fast gradient sign method (FGSM) with different \u000f. ",
+        "bbox": [
+            173,
+            438,
+            823,
+            465
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "messy, especially near boundaries. To our surprise, however, the center loss performs the worst on CIFAR-10, implying its weak robustness under adversarial perturbation. ",
+        "bbox": [
+            171,
+            492,
+            823,
+            521
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.4 CLUSTERING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            539,
+            305,
+            553
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Compact intra-class features can be used in clustering tasks. We evaluate K-means and agglomerative clustering (ward linkage) performance of features under different supervision signals. For MNIST, CIFAR-10, and ILSVRC-sub, 10,000 images from their corresponding testing set are used for clustering. As for the face model, we use 12,776 face images of 466 different identities from FRGC Phillips et al. (2005) dataset. For evaluation, 12 pre-trained models mentioned above are employed, i.e. 3 different losses for each of 4 datasets. Normalized Mutual Information (NMI) Strehl & Ghosh (2002) is selected as the clustering performance evaluation metric. The results in Table 5 show the consistent superiority of our algorithm. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            676
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.5 FACE VERIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            695,
+            356,
+            709
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We also evaluate the performance of our algorithm on a widely used verification benchmark LFW Huang et al. (2008). The dataset contains 13,233 faces from 5749 individuals with different poses and expressions. We use the models trained on 0.32M CASIA-WebFace mentioned above. We also implement a model trained with triplet loss with the same training data and network. There is no overlap between our training data and LFW dataset. We use MTCNN Zhang et al. (2016) to align the face images of LFW like what we do on CASIA-WebFace. Instructed by the protocol for unrestricted with labeled outside data Huang & Learned-Miller (2014), we report the result of verification performance of 6,000 pairs of faces in Table 6 and Figure 7. We only train our model with 0.32M outside face images on a single network, so our purpose is not to improve state-of-the-art accuracy but a good comparison of isomax loss, center loss, softmax loss and triplet loss under the same condition. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            875
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our proposed method is more efficient and suitable in verification task compared with softmax loss baseline and also outperforms center loss and triplet loss under the same condition. Since the dataset we use for training has more than 10,000 classes, making centers for each class difficult to determine in a mini-batch. So the model with center loss surpasses the model with softmax loss by a small margin while ours outperforms it by a relatively large margin. Triplet loss is another baseline we want to compare with. Due to its long training process, we partially plot it in Figure 7. The accuracy of triplet loss finally plateaus at $9 6 . 8 8 \\%$ , which is lower than the accuracy reported in the original paper. The small amount of training data and complex training tricks that we do not tune well may be the reasons. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/94ecd74e2fbd497563ffa88989a5ea1a545401b80f8c7a7385d792be7c468fde.jpg",
+        "table_caption": [
+            "Table 5: Clustering results. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Datasets</td><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=1>K-meansNMI score</td><td rowspan=1 colspan=1>AgglomerativeNMI score</td></tr><tr><td rowspan=1 colspan=1>MNIST</td><td rowspan=1 colspan=1>SoftmaxCenterLossIsomax</td><td rowspan=1 colspan=1>0.90310.92700.9666</td><td rowspan=1 colspan=1>0.91100.90980.9404</td></tr><tr><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>SoftmaxCenter Loss</td><td rowspan=1 colspan=1>0.73660.74280.7837</td><td rowspan=1 colspan=1>0.71360.72430.7541</td></tr><tr><td rowspan=1 colspan=1>ILSVRC-sub</td><td rowspan=1 colspan=1>SoftmaxCenter LossIsomax</td><td rowspan=1 colspan=1>0.71910.71930.7349</td><td rowspan=1 colspan=1>0.76580.77130.7831</td></tr><tr><td rowspan=1 colspan=1>CASIA-WebFace</td><td rowspan=1 colspan=1>SoftmaxCenterLossIsomax</td><td rowspan=1 colspan=1>0.94040.94210.9461</td><td rowspan=1 colspan=1>0.96850.96910.9721</td></tr></table>",
+        "bbox": [
+            261,
+            101,
+            736,
+            299
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/c9207284d591af69f7f5a5a7e4ed23e7a2d7396c14cc07ab1584ccdbac700902.jpg",
+        "table_caption": [
+            "Table 6: Verification accuracy on LFW. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Methods</td><td rowspan=1 colspan=1>Networks</td><td rowspan=1 colspan=1>Outside Data</td><td rowspan=1 colspan=1>Acc(%)</td></tr><tr><td rowspan=2 colspan=1>Yi et al. (2014)DeepFace Taigman et al. (2014)FaceNet Schroff et al. (2015)Deep FR Parkhi et al. (2015)DeepID-2+ Sun et al.(2015)</td><td rowspan=2 colspan=1>131125</td><td rowspan=1 colspan=1>0.49 M</td><td rowspan=2 colspan=1>97.7397.3599.6398.9599.47</td></tr><tr><td rowspan=1 colspan=1>4M200M2.6 M1</td></tr><tr><td rowspan=4 colspan=1>Softmax LossCenter LossTriplet LossIsomax Loss</td><td rowspan=2 colspan=1>11</td><td rowspan=1 colspan=1>0.32 M</td><td rowspan=2 colspan=1>97.5097.63</td></tr><tr><td rowspan=1 colspan=1>0.32 M</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.32 M</td><td rowspan=1 colspan=1>96.88</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.32 M</td><td rowspan=1 colspan=1>98.03</td></tr></table>",
+        "bbox": [
+            264,
+            354,
+            733,
+            501
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/44f00d71423a7a0e685a86bb6a7126e09ca227563cfea8755c9a877740a486ce.jpg",
+        "image_caption": [
+            "Figure 7: LFW verification accuracy during training. (a): Triplet loss converges very slowly. (b): Zooming in the final stage of training shows that our proposed loss achieves better performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            565,
+            782,
+            756
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            839,
+            825,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a new isotropic loss together with the original softmax loss named isomax loss. With the joint supervision signal, CNNs generate more isotropic feature distribution for each class, and the Euclidean distance in the class decreases. The 2-D visualization and extensive experiments on different datasets for different tasks show the effectiveness of our approach. Comparison to other related works illustrates the advantage of our method on tasks using feature distance. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            204
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            224,
+            285,
+            239
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. arXiv preprint arXiv:1603.04467, 2016. ",
+        "bbox": [
+            174,
+            247,
+            826,
+            290
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Doug Beeferman and Adam Berger. Agglomerative clustering of a search engine query log. In Proceedings of the sixth ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 407–416. ACM, 2000. ",
+        "bbox": [
+            174,
+            300,
+            823,
+            343
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Leon Bottou. Large-scale machine learning with stochastic gradient descent. In ´ Proceedings of COMPSTAT’2010, pp. 177–186. Springer, 2010. ",
+        "bbox": [
+            169,
+            352,
+            825,
+            381
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Alex Berg, Sanjeev Satheesh, H Su, Aditya Khosla, and L Fei-Fei. Imagenet large scale visual recognition competition 2012 (ilsvrc2012), 2012. ",
+        "bbox": [
+            171,
+            390,
+            823,
+            420
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yinpeng Dong, Fangzhou Liao, Tianyu Pang, Xiaolin Hu, and Jun Zhu. Discovering adversarial examples with momentum. arXiv preprint arXiv:1710.06081, 2017. ",
+        "bbox": [
+            173,
+            428,
+            823,
+            458
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan R Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012. ",
+        "bbox": [
+            174,
+            467,
+            823,
+            510
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gary B Huang and Erik Learned-Miller. Labeled faces in the wild: Updates and new reporting procedures. Dept. Comput. Sci., Univ. Massachusetts Amherst, Amherst, MA, USA, Tech. Rep, pp. 14–003, 2014. ",
+        "bbox": [
+            173,
+            518,
+            826,
+            561
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gary B Huang, Marwan Mattar, Tamara Berg, and Eric Learned-Miller. Labeled faces in the wild: A database forstudying face recognition in unconstrained environments. In Workshop on faces in’Real-Life’Images: detection, alignment, and recognition, 2008. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            614
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456, 2015. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            665
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            174,
+            676,
+            821,
+            704
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            174,
+            713,
+            821,
+            729
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012. ",
+        "bbox": [
+            176,
+            738,
+            823,
+            780
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, LD Jackel, Leon Bottou, Corinna Cortes, John S Denker, Harris Drucker, Isabelle ´ Guyon, UA Muller, Eduard Sackinger, Patrice Simard, et al. Learning algorithms for classification: A comparison on handwritten digit recognition. Neural networks: the statistical mechanics perspective, 261:276, 1995. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            173,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Weiyang Liu, Yandong Wen, Zhiding Yu, and Meng Yang. Large-margin softmax loss for convolutional neural networks. In ICML, pp. 507–516, 2016. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Omkar M Parkhi, Andrea Vedaldi, Andrew Zisserman, et al. Deep face recognition. In BMVC, volume 1, pp. 6, 2015. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "P Jonathon Phillips, Patrick J Flynn, Todd Scruggs, Kevin W Bowyer, Jin Chang, Kevin Hoffman, Joe Marques, Jaesik Min, and William Worek. Overview of the face recognition grand challenge. In Computer vision and pattern recognition, 2005. CVPR 2005. IEEE computer society conference on, volume 1, pp. 947–954. IEEE, 2005. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            196
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ce Qi and Fei Su. Contrastive-center loss for deep neural networks. arXiv preprint arXiv:1707.07391, 2017. ",
+        "bbox": [
+            171,
+            207,
+            825,
+            234
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Florian Schroff, Dmitry Kalenichenko, and James Philbin. Facenet: A unified embedding for face recognition and clustering. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 815–823, 2015. ",
+        "bbox": [
+            173,
+            244,
+            825,
+            287
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hidetoshi Shimodaira. Improving predictive inference under covariate shift by weighting the loglikelihood function. Journal of statistical planning and inference, 90(2):227–244, 2000. ",
+        "bbox": [
+            173,
+            295,
+            821,
+            325
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. ",
+        "bbox": [
+            174,
+            333,
+            821,
+            363
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A. Strehl and J. Ghosh. Cluster ensembles — a knowledge reuse framework for combining multiple partitions. Journal of Machine Learning Research, 3:583–617, 2002. ",
+        "bbox": [
+            173,
+            371,
+            823,
+            401
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yi Sun, Yuheng Chen, Xiaogang Wang, and Xiaoou Tang. Deep learning face representation by joint identification-verification. In Advances in neural information processing systems, pp. 1988–1996, 2014. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            452
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yi Sun, Xiaogang Wang, and Xiaoou Tang. Deeply learned face representations are sparse, selective, and robust. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2892–2900, 2015. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            503
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Sergey Ioffe, Vincent Vanhoucke, and Alexander A Alemi. Inception-v4, inception-resnet and the impact of residual connections on learning. In AAAI, pp. 4278–4284, 2017. ",
+        "bbox": [
+            173,
+            511,
+            825,
+            554
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yaniv Taigman, Ming Yang, Marc’Aurelio Ranzato, and Lior Wolf. Deepface: Closing the gap to human-level performance in face verification. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1701–1708, 2014. ",
+        "bbox": [
+            174,
+            563,
+            823,
+            607
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural networks for machine learning, 4(2):26– 31, 2012. ",
+        "bbox": [
+            174,
+            614,
+            823,
+            657
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yandong Wen, Kaipeng Zhang, Zhifeng Li, and Yu Qiao. A discriminative feature learning approach for deep face recognition. In European Conference on Computer Vision, pp. 499–515. Springer, 2016. ",
+        "bbox": [
+            174,
+            666,
+            823,
+            709
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Dong Yi, Zhen Lei, Shengcai Liao, and Stan Z Li. Learning face representation from scratch. arXiv preprint arXiv:1411.7923, 2014. ",
+        "bbox": [
+            171,
+            718,
+            823,
+            747
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kaipeng Zhang, Zhanpeng Zhang, Zhifeng Li, and Yu Qiao. Joint face detection and alignment using multitask cascaded convolutional networks. IEEE Signal Processing Letters, 23(10):1499–1503, 2016. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            799
+        ],
+        "page_idx": 12
+    }
+]

parse/train/rygxdA4YPS/rygxdA4YPS.md

@@ -0,0 +1,513 @@
+# ADASCALE SGD: A SCALE-INVARIANT ALGORITHM FOR DISTRIBUTED TRAINING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+When using distributed training to speed up stochastic gradient descent, learning rates must adapt to new scales in order to maintain training effectiveness. Re-tuning these parameters is resource intensive, while fixed scaling rules often degrade model quality. We propose AdaScale SGD, a practical and principled algorithm that is approximately scale invariant. By continually adapting to the gradient’s variance, AdaScale often trains at a wide range of scales with nearly identical results. We describe this invariance formally through AdaScale’s convergence bounds. As the batch size increases, the bounds maintain final objective values, while smoothly transitioning away from linear speed-ups. In empirical comparisons, AdaScale trains well beyond the batch size limits of popular “linear learning rate scaling” rules. This includes large-scale training without model degradation for machine translation, image classification, object detection, and speech recognition tasks. The algorithm introduces negligible computational overhead and no tuning parameters, making AdaScale an attractive choice for large-scale training.
+
+# 1 INTRODUCTION
+
+Large datasets and large models underlie much of the recent success of machine learning. Training such models is time consuming, however, as stochastic gradient descent algorithms can require days or weeks to train effectively. Thus, procedures that speed up SGD are valuable. Faster training enables consideration of more data and models, which expands the capabilities of machine learning.
+
+To speed up SGD, distributed systems can process thousands of training examples per iteration. But training at large scales also creates a major algorithmic challenge. Specifically, learning rates must adapt to each scale. Without choosing these training parameters carefully, scaled SGD frequently trains low-quality models, producing a waste of resources rather than a useful model.
+
+To adapt learning rates, “fixed scaling rules” are standard but unreliable strategies. Goyal et al. (2017) popularized “linear learning rate scaling,” which can work well, especially for computer vision tasks (Krizhevsky, 2014; Devarakonda et al., 2017; Jastrz˛ebski et al., 2018; Smith et al., 2018; Lin et al., 2019). For other problems or larger scales, however, linear scaling often fails. This fact is well-known in theory (Yin et al., 2018; Jain et al., 2018; Ma et al., 2018) and in practice (Goyal et al., 2017). Other fixed scaling rules are also undependable. Golmant et al. (2018) test three rules—linear, root, and identity—and conclude that each one often degrades model quality. Shallue et al. (2019) compute near-optimal parameters for many tasks and scales, and the results do not align with any fixed rule. To ensure effective training, the authors recommend avoiding such rules and re-tuning parameters for each new scale—an inconvenient and resource-intensive solution.
+
+We propose AdaScale SGD. A practical but principled algorithm, AdaScale more reliably scales training by adapting to the gradient’s variance. Decreased gradient variance is the fundamental impact of large batch sizes. Thus, scaling provides little gain if the variance is already “small” at small scales. In such cases, AdaScale increases the learning rate conservatively, and large-scale training progresses similarly to the small-batch setting. For iterations with “large” gradient variance, AdaScale increases the learning rate aggressively, and the per-iteration progress dramatically increases.
+
+AdaScale is approximately scale invariant, a quality that simplifies large-batch training. With no changes to learning rates or other inputs, AdaScale can train at many scales with similar results. This leads to two important innovations: (i) AdaScale improves the translation of training configurations between scales, which is useful for scaling up tasks or adapting to dynamic resource availability;
+
+![](images/7033832bae17853271dffefbbaa6dc531fea06a55be14d153ad7067c03324f14.jpg)  
+Figure 1: Motivating results. For cifar10, AdaScale preserves model quality for many scales $S$ . When plotted in terms of scale-invariant iterations, training curves align closely. With AdaScale, “warm-up” behavior emerges from adapting a simple learning rate schedule (exponential decay) to scale $S$ (learning rate plot cropped to show behavior). Meanwhile, linear scaling (with warm-up heuristic) degrades model quality as $S$ increases.
+
+and (ii) AdaScale works at scale with simple learning rate schedules, which eliminates the need for “warm-up” heuristics (Goyal et al., 2017). Qualitatively, AdaScale and warm-up have similar effects on learning rates, but with AdaScale, this behavior emerges from a principled and adaptive mechanism, not hand-tuned parameters.
+
+We provide theoretical results that formalize this approximate scale invariance. Bounds for all scales converge to identical objective values. In contrast, the linear scaling rule requires fewer iterations but compromises model quality and training stability, causing divergence as the batch size increases.
+
+We perform large-scale empirical evaluations on five training benchmarks. Tasks include image classification, machine translation, object detection, and speech recognition. The results align well with our theory, as AdaScale systematically preserves model quality across many scales. This includes training ImageNet with batch size $3 2 \mathrm { k }$ and Transformer with $2 6 2 \mathrm { k }$ max tokens per batch.
+
+To provide context for our description of AdaScale, Figure 1 includes results from a simple scaling experiment using CIFAR-10 data. These results illustrate the concept of scale invariance, AdaScale’s qualitative impact on learning rates, and a failure case for the linear scaling rule.
+
+# 2 PROBLEM FORMULATION
+
+We focus on quickly computing approximate solutions to the problem
+
+$$
+\operatorname* { m i n i m i z e } _ { \mathbf { w } \in \mathbb { R } ^ { d } } F ( \mathbf { w } ) , \quad \mathrm { w h e r e } \quad F ( \mathbf { w } ) = \mathbb { E } _ { \mathbf { x } \sim \mathcal { X } } \left[ f ( \mathbf { w } , \mathbf { x } ) \right] .
+$$
+
+Here w parameterizes a machine learning model, while $\mathcal { X }$ denotes a distribution over batches of training data. We assume that $F$ and $f$ are differentiable and that $\mathbb { E } _ { \mathbf { x } \sim \mathcal { X } } \left[ \nabla _ { \mathbf { w } } f ( \mathbf { w } , \mathbf { x } ) \right] = \nabla F ( \mathbf { w } )$ .
+
+Stochastic gradient descent is a popular algorithm for solving (P1). Let $\mathbf { w } _ { t }$ denote the model parameters when iteration $t$ begins. During this iteration, SGD samples a batch $\mathbf { x } _ { t } \sim \mathcal { X }$ and computes the gradient $\mathbf { g } _ { t }  \nabla _ { \mathbf { w } } f ( \mathbf { w } _ { t } , \mathbf { x } _ { t } )$ . SGD then applies the update $\mathbf { w } _ { t + 1 }  \mathbf { w } _ { t } - \eta _ { t } \mathbf { g } _ { t }$ . Here $\eta _ { t }$ is the learning rate. Given a schedule $\mathtt { l r } : \mathbb { Z } _ { \ge 0 } \to \mathbb { R } _ { > 0 }$ , SGD defines $\eta _ { t } = 1 \mathbf { r } ( t )$ . For our experiments in $\ S 4 , \beth \ b \mathrm { r }$ is an exponential decay or step decay function. SGD completes training after $T$ iterations.
+
+To speed up training, practitioners often parallelize gradient computation across multiple devices. Algorithm 1 defines a scaled SGD algorithm. At scale $S$ , the algorithm samples $S$ independent batches during each iteration. After computing the gradient for each batch in parallel, the algorithm applies the mean of these gradients (in place of $\mathbf { g } _ { t }$ ) when updating model parameters.
+
+But scaling training in this way creates a considerable algorithmic challenge. Each new scale requires a new learning rate schedule, which is inconvenient and resource intensive to obtain. To help address this challenge, we propose a scaled SGD algorithm that is approximately scale invariant.
+
+Definition 1. Let $\mathbf { w } _ { T }$ denote the (possibly random) result of a scaled SGD algorithm. Fixing all algorithm inputs except scale $S$ , the algorithm is scale invariant $i f \mathbf { w } _ { T }$ does not depend on $S$ .
+
+A scale-invariant algorithm makes parallelizing training significantly easier. Such an algorithm can scale to any available amount of computational resources, and there is no need for parameter retuning, unreliable heuristics, or algorithmic expertise from users.
+
+<table><tr><td>Algorithm1Scaled SGD</td><td>Algorithm2AdaScale SGD</td></tr><tr><td>function Scaled_SGD(S,lr,T,X, f,wo)</td><td>function AdaScale(S,lr,Ts1,X, f,wo)</td></tr><tr><td>for t=0,1,2,...,T-1 do</td><td>initialize To ←O; t←0</td></tr><tr><td>gt ← compute_gradient(Wt,S,X,f)</td><td>while Tt &lt;Ts1do</td></tr><tr><td>nt ←lr(t)</td><td>gt ← compute_gradient(Wt,S,X,f)</td></tr><tr><td>Wt+1←Wt-ntgt return WT</td><td>#Compute gain rt ∈ [1,S] (see $3.3):</td></tr><tr><td>function compute_gradient(Wt,S,X,f)</td><td>E[σ²(wt)+|/VF(wt)²2] rt↑</td></tr><tr><td>in parallel for i=1,..., Sdo</td><td>E [σ²(wt)+|/VF(wt)l|2]</td></tr><tr><td>x(i)← sample_batch(X)</td><td>Nt ← rt ·lr([Tt])</td></tr><tr><td>g(i) ← Vwf(Wt,x(i))</td><td>Wt+1←Wt-Ntgt</td></tr><tr><td>returm∑=1g</td><td>Tt+1←Tt+rt;t←t+1</td></tr><tr><td></td><td>return Wt</td></tr></table>
+
+# 3 ADASCALE SGD ALGORITHM
+
+This section introduces our AdaScale algorithm. As motivation, we first consider the role of gradient variance in SGD. We later provide practical guidance for variance estimation and momentum tuning.
+
+3.1 INTUITION: IDENTITY SCALING, LINEAR SCALING, AND GRADIENT VARIANCE
+
+We now consider two fixed scaling rules, which influence the design of AdaScale. One of these rules is identity scaling, which keeps the training configuration constant for all scales:
+
+Definition 2. To apply the identity scaling rule to Algorithm 1, use the same lr and $T$ for all $S$
+
+Note that this rule has little practical appeal, since it fails to reduce the number of training iterations. A second and more popular strategy is linear learning rate scaling:
+
+Definition 3. To apply the linear learning rate scaling rule to Algorithm 1, use $\mathbf { 1 r } ( t ) = S { \cdot } \mathbf { 1 r } _ { S 1 } ( S t )$ and $T = \lceil T _ { S 1 } / S \rceil$ , where $\scriptstyle 1 \mathbf { r } _ { \mathrm { S 1 } }$ and $T _ { S 1 }$ denote the learning rate schedule and total steps for $S = 1$ .
+
+Conceptually, linear scaling treats SGD as a perfectly parallelizable algorithm. If true, applying gradients from $S$ batches in parallel achieves the same result as doing so in sequence.
+
+For special cases of (P1), the identity and linear rules result in scale-invariant algorithms. To show this, we first define the variance quantities
+
+In words, $\sigma ^ { 2 } ( \mathbf { w } )$ sums the variances of each entry in $\nabla _ { \mathbf { w } } { f } ( \mathbf { w } , \mathbf { x } )$ . By sampling batches independently, scaling fundamentally impacts SGD by reducing this variance. Given $\mathbf { w } _ { t }$ in Algorithm 1, we have $\begin{array} { r } { \dot { \bf c o v } ( \bar { \bf g } _ { t } , \breve { \bar { \bf g } } _ { t } ) = \frac { 1 } { S } \Sigma ( { \bf w } _ { t } ) } \end{array}$ and $\mathbb { E } \left[ \bar { \bf g } _ { t } \right] = \nabla \dot { F } ( { \bf w } _ { t } )$ . Here, only the covariance depends on $S$ .
+
+Consider the special case of zero gradient variance. In this case, identity scaling performs ideally: Proposition 1 (Scale-invariant SGD for deterministic gradients). If $\sigma ^ { 2 } ( \mathbf { w } ) = 0$ for all w $\in \mathbb { R } ^ { d }$ , then applying identity scaling to Algorithm 1 results in a scale-invariant algorithm.
+
+Although identity scaling does not speed up training, Proposition 1 is critical for framing the impact of large scales. If the gradient variance is “small,” then we cannot expect large gains from increasing $S$ —a larger scale has little effect on $\bar { \bf g } _ { t }$ . With “large” variance, however, the opposite is true:
+
+Proposition 2 (Scale-invariant SGD for extreme stochasticity). Consider fixed covariance matrix $\tilde { \Sigma } \in \mathbb S _ { + + } ^ { d }$ , learning rate value $\tilde { \eta } \in \mathbb { R } _ { > 0 }$ , and training duration $\tilde { T }$ . For a given $\nu \in \mathbb { R } _ { > 0 }$ , assume $\nabla _ { \mathbf { w } } { f } ( \mathbf { w } , \mathbf { x } ) \sim \mathcal { N } ( \nabla F ( \mathbf { w } ) , \nu \tilde { \Sigma } )$ , and apply linear scaling to Algorithm 1 with $\mathbf { 1 } \mathbf { r } _ { S 1 } ( t ) = \nu ^ { - 1 } \tilde { \eta }$ and $T _ { S 1 } = \nu \tilde { T }$ . The resulting scaled SGD algorithm is scale-invariant in the limit $\nu \to + \infty$ .
+
+In less formal terms, linear scaling leads to scale-invariance in the case of very large gradient variance (as well as small learning rates and many iterations, to compensate for this variance). Since increasing $S$ decreases variance, it is natural that scaling yields large speed-ups in this extreme case.
+
+In practice, the gradient’s variance is neither zero nor infinite, and both identity and linear scaling may perform poorly. Moreover, the gradient’s variance does not remain constant throughout training. A scale-invariant algorithm, it seems, must continually adapt to the state of training.
+
+# 3.2 ADASCALE DEFINITION
+
+AdaScale, defined in Algorithm 2, adaptively interpolates between identity and linear scaling, based on the expectation of $\bar { \sigma } ^ { 2 } ( \mathbf { w } _ { t } )$ . During iteration $t$ , AdaScale multiplies the learning rate by the “gain ratio” $r _ { t } \in [ 1 , S ]$ : $\eta _ { t } = r _ { t } \cdot \mathtt { l r } ( \left\lfloor \tau _ { t } \right\rfloor )$ . Here $\tau _ { t }$ is the “scale-invariant iteration,” defined as $\begin{array} { r } { \tau _ { t } = \sum _ { t ^ { \prime } = 0 } ^ { t - 1 } r _ { t ^ { \prime } } } \end{array}$ . The idea is that iteration $t$ performs the equivalent of $r _ { t }$ single-batch iterations, and $\tau _ { t }$ accumulates this progress. AdaScale concludes when $\tau _ { t } \geq T _ { \mathrm { S I } }$ , where $T _ { \mathrm { S I } }$ is the total scaleinvariant iterations. Since $r _ { t } \in [ 1 , S ]$ , AdaScale requires at least $\lceil T _ { \mathrm { S I } } / S \rceil$ and at most $T _ { \mathrm { S I } }$ iterations.
+
+The identity and linear rules correspond to two special cases of AdaScale. If $r _ { t } = 1$ for all $t$ , the algorithm equates to SGD with identity scaling. Similarly, if $r _ { t } = S$ for all $t$ , we have linear scaling. Thus, to approximate scale-invariance, $\ S 3 . 1$ suggests setting $r _ { t } \approx 1$ when the gradient’s variance is small and $r _ { t } \approx S$ when this variance is large. AdaScale achieves this by defining
+
+$$
+r _ { t } = \mathbb { E } \left[ \sigma ^ { 2 } ( \mathbf { w } _ { t } ) + \left. \nabla F ( \mathbf { w } _ { t } ) \right. ^ { 2 } \right] \Big / \mathbb { E } \left[ \frac { 1 } { S } \sigma ^ { 2 } ( \mathbf { w } _ { t } ) + \left. \nabla F ( \mathbf { w } _ { t } ) \right. ^ { 2 } \right] .
+$$
+
+The expectations here are with respect to the distribution of $\mathbf { w } _ { t }$ , and we must approximate $r _ { t }$ in practice (see $\ S 3 . 3 )$ . This definition of $r _ { t }$ ensures that as $S$ increases, $\mathbb { E } [ \langle \mathbf { w } _ { t + 1 } - \mathbf { w } _ { t } , \nabla F ( \mathbf { w } _ { t } ) \rangle ]$ and $\mathbb { E } [ \| \mathbf { w } _ { t + 1 } - \mathbf { w } _ { t } \| ^ { 2 } ]$ increase multiplicatively by $r _ { t }$ . This leads to our scale-invariant bound in $\ S 5$ .
+
+# 3.3 PRACTICAL CONSIDERATIONS
+
+If $S ~ = ~ 1$ in AdaScale, then $r _ { t } ~ = ~ 1$ for all iterations. For larger scales, $r _ { t }$ depends on $\mathbb { E } \left[ \sigma ^ { 2 } ( \mathbf { w } _ { t } ) \right]$ and $\mathbb { E } \left[ \| \nabla F ( \mathbf { w } _ { t } ) \| ^ { 2 } \right]$ , and a practical implementation must efficiently approximate these values. Fortunately, the per-batch gradients $\mathbf { g } _ { t } ^ { ( 1 ) } , \ldots , \mathbf { g } _ { t } ^ { ( S ) }$ and aggregated gradient $\bar { \bf g } _ { t }$ are readily available in distributed SGD algorithms. This makes approximating $r _ { t }$ straightforward. In particular, we define
+
+$$
+\begin{array} { r } { \hat { \sigma } _ { t } ^ { 2 } = \frac { 1 } { S - 1 } \sum _ { i = 1 } ^ { S } \| { \bf g } _ { t } ^ { ( i ) } \| ^ { 2 } - \frac { S } { S - 1 } \left\| \bar { \bf g } _ { t } \right\| ^ { 2 } , } \end{array}
+$$
+
+$$
+\begin{array} { r } { \mathrm { a n d } \hat { \mu } _ { t } ^ { 2 } = \left. \bar { \bf g } _ { t } \right. ^ { 2 } - \frac { 1 } { S } \hat { \sigma } _ { t } ^ { 2 } . } \end{array}
+$$
+
+![](images/5d22230dc4ee78ba8e1391d3a4671b5a17321786f1e9b45f9e0d1c0341328c55.jpg)  
+Figure 2: Gain ratios. Plots compare moving average $r _ { t }$ estimates to values computed offline (using 1000 batches). The values align closely. Abrupt changes align with learning rate step changes.
+
+Here $\hat { \sigma } _ { t } ^ { 2 }$ and $\hat { \mu } _ { t } ^ { 2 }$ are unbiased estimates of $\mathbb { E } \left[ \sigma ^ { 2 } ( \mathbf { w } _ { t } ) \right]$ and E $\left[ \| \nabla F ( \mathbf { w } _ { t } ) \| _ { 2 } ^ { 2 } \right]$ . To ensure robustness to estimation variance, we estimate $r _ { t }$ by plugging in moving averages $\bar { \sigma } _ { t } ^ { \omega ^ { - } }$ and $\bar { \mu } _ { t } ^ { 2 }$ , which average $\hat { \sigma } _ { t } ^ { 2 }$ and $\hat { \mu } _ { t } ^ { 2 }$ over prior iterations. Our implementation uses exponential moving average parameter $\bar { \theta ^ { } } = \operatorname* { m a x } \{ 1 - S / 1 0 0 0 , 0 \}$ , where $\theta = 0$ results in no averaging. We find that AdaScale is robust to the choice of $\theta$ , and we provide evidence of this in Appendix C. To initialize, we set $r _ { 0 } \gets 1$ , and for iterations $t < ( 1 - \theta ) ^ { - 1 }$ , we define $\hat { \sigma } _ { t } ^ { 2 }$ and $\bar { \mu } _ { t } ^ { 2 }$ as the mean of past samples. Before averaging, we clip estimates so that $\hat { \sigma } _ { t } ^ { 2 } \geq 1 0 ^ { - 6 }$ (to prevent division by zero) and $\hat { \mu } _ { t } ^ { 2 } \geq \bar { 0 }$ (to ensure $r _ { t } \in [ 1 , S ] )$ .
+
+To verify these estimators, Figure 2 compares moving average estimates to offline estimates using model checkpoints. These plots also provide examples of gain ratios for practical problems. We note that numerous prior works—for example, (Schaul et al., 2013; Kingma & Ba, 2015; McCandlish et al., 2018)—have relied on similar moving averages to estimate gradient moments.
+
+One final practical consideration is the momentum parameter $\rho$ when using AdaScale with momentum-SGD. The performance of momentum-SGD depends less critically on $\rho$ than the learning rate (Shallue et al., 2019). For this reason, we find that AdaScale often performs well if $\rho$ remains constant across scales and iterations. This approach to momentum scaling has also succeeded in prior works involving the linear scaling rule (Goyal et al., 2017; Smith et al., 2018).
+
+# 4 EMPIRICAL COMPARISONS
+
+We evaluate AdaScale on five practical training benchmarks. We assess scale invariance by comparing training curves across scales. We assess impact on training times by comparing total iterations. We consider a variety of tasks, models (He et al., 2016a;b; Amodei et al., 2016; Vaswani et al., 2017; Redmon & Farhadi, 2018), and datasets (Deng et al., 2009; Krizhevsky, 2009; Everingham et al., 2010; Panayotov et al., 2015). Table 1 summarizes our training benchmarks. Due to space limitations, we provide additional implementation details in Appendix B.
+
+![](images/2b41e292e099799220f7b82e923f0d11122eac7ca58c227691eb842790861eea.jpg)  
+Figure 3: AdaScale training curves. For many scales and benchmarks, AdaScale trains quality models. Training curves align closely in terms of $\tau _ { t }$ . In all cases, $\eta _ { t }$ warms up gradually at the start of training, even though all lr schedules are simple exponential or step decay functions (which are non-increasing in $t$ ).
+
+For each benchmark, we use one simple learning rate schedule. Specifically, lr is an exponential decay function for cifar10 and speech, and a step decay function otherwise. We use standard $\mathtt { l r }$ parameters for imagenet and yolo. Otherwise, we use tuned parameters that approximately maximize the validation metric (to our knowledge, there are no standard schedules for solving speech and transformer with momentum-SGD). We use momentum $\rho = 0 . 9$ except for transformer, in which case we use $\rho = 0 . 9 9$ for greater training stability.
+
+Figure 3 (and Figure 1) contains AdaScale training curves for the benchmarks and many scales. Each curve plots the mean of five distributed training runs with varying random seeds. As $S$ increases, AdaScale trains for fewer iterations but consistently preserves model quality. Illustrating AdaScale’s approximate scale invariance, the training curves align closely when plotted in terms of scale-invariant iterations.
+
+Table 1: Overview of training benchmarks.   
+
+<table><tr><td>Name</td><td>Task</td><td>Model</td><td>Dataset</td><td>Metric</td></tr><tr><td>cifar10</td><td>Image classification</td><td>ResNet-18 (v2)</td><td>CIFAR-10</td><td>Top-1 accuracy (%)</td></tr><tr><td>imagenet</td><td>Image classification</td><td>ResNet-50 (v1)</td><td>ImageNet</td><td>Top-1 accuracy (%)</td></tr><tr><td>speech</td><td>Speech recognition</td><td>Deep speech 2</td><td>LibriSpeech</td><td>Word accuracy (%)</td></tr><tr><td>transformer</td><td>Machine translation</td><td>Transformer base</td><td>WMT-2014</td><td>BLEU</td></tr><tr><td>yolo</td><td>Object detection</td><td>YOLOv3</td><td>PASCAL VOC</td><td>mAP (%)</td></tr></table>
+
+![](images/555de7d5fe3ebe3544276123b17f0224afbdb9be2ddef935ae6a410b6daa57de.jpg)  
+Figure 4: Elastic AdaScaling. For imagenet, AdaScale is approximately scale invariant, even if $S$ changes abruptly (at $\tau _ { t } = 1 3 3 \mathbf { k }$ , 225k). Unlike AdaScale, LSW degrades model quality in this setting (see Table 2). Elastic scaling comparisons consider one random trial; future versions of this work will include five trials.
+
+For $S > 1$ , AdaScale’s learning rate increases gradually during initial training, despite the fact that $\mathtt { l r }$ is non-increasing. Unlike warm-up heuristics (Goyal et al., 2017), this behavior emerges naturally from a principled algorithm, not hand-tuned user input. Thus, AdaScale provides not only a compelling alternative to warm-up but also a plausible explanation for warm-up’s success.
+
+For imagenet, we also consider elastic scaling. Here, the only change to AdaScale is that $S$ changes abruptly after some iterations. We consider two cases: (i) $S$ increases from 32 to 64 at $\tau _ { t } = T _ { \mathrm { S I } } / 4$ and from 64 to 128 at $\tau _ { t } = T _ { \mathrm { S I } } / 2$ , and (ii) the scale decreases at the same points, from 128 to 64 to 32. In Figure 4, we include training curves from this setting. AdaScale remains approximately scale invariant, highlighting AdaScale’s value for the common scenario of dynamic resource availability.
+
+Table 2: Comparison of final model quality. Shorthand: AS=AdaScale, LSW=Linear scaling rule with warm-up, gray=model quality significantly worse than for $S = 1$ (5 trials, 0.95 significance), N/A=training diverges, Elastic $\uparrow / \downarrow =$ elastic scaling with increasing/decreasing scale (see Figure 4). Linear scaling leads to poor model quality as the scale increases, while AdaScale preserves model performance for nearly all cases.   
+
+<table><tr><td>Task</td><td>S</td><td>Total</td><td colspan="2">Validation metric</td><td colspan="2">Training loss</td><td colspan="2">Total iterations</td></tr><tr><td></td><td></td><td>batch size</td><td>AS</td><td>LSW</td><td>AS</td><td>LSW</td><td>AS</td><td>LSW</td></tr><tr><td>cifar10</td><td>1</td><td>128</td><td>94.1</td><td>94.1</td><td>0.157</td><td>0.157</td><td>39.1k</td><td>39.1k</td></tr><tr><td></td><td>8</td><td>1.02k</td><td>94.1</td><td>94.0</td><td>0.153</td><td>0.161</td><td>5.85k</td><td>4.88k</td></tr><tr><td></td><td>16</td><td>2.05k</td><td>94.1</td><td>93.6</td><td>0.150</td><td>0.163</td><td>3.36k</td><td>2.44k</td></tr><tr><td></td><td>32</td><td>4.10k</td><td>94.1</td><td>92.8</td><td>0.145</td><td>0.177</td><td>2.08k</td><td>1.22k</td></tr><tr><td></td><td>64</td><td>8.19k</td><td>93.9</td><td>76.6</td><td>0.140</td><td>0.272</td><td>1.41k</td><td>611</td></tr><tr><td>imagenet</td><td>1</td><td>256</td><td>76.4</td><td>76.4</td><td>1.30</td><td>1.30</td><td>451k</td><td>451k</td></tr><tr><td></td><td>16</td><td>4.10k</td><td>76.5</td><td>76.3</td><td>1.26</td><td>1.31</td><td>33.2k</td><td>28.2k</td></tr><tr><td></td><td>32</td><td>8.19k</td><td>76.6</td><td>76.1</td><td>1.23</td><td>1.33</td><td>18.7k</td><td>14.1k</td></tr><tr><td></td><td>64</td><td>16.4k</td><td>76.5</td><td>75.6</td><td>1.19</td><td>1.35</td><td>11.2k</td><td>7.04k</td></tr><tr><td></td><td>128</td><td>32.8k</td><td>76.5</td><td>73.3</td><td>1.14</td><td>1.51</td><td>7.29k</td><td>3.52k</td></tr><tr><td></td><td>Elastic↑</td><td>various</td><td>76.8</td><td>75.7</td><td>1.15</td><td>1.36</td><td>11.6k</td><td>7.04k</td></tr><tr><td></td><td>Elastic↓</td><td>various</td><td>76.6</td><td>73.8</td><td>1.23</td><td>1.46</td><td>13.7k</td><td>9.68k</td></tr><tr><td>speech</td><td>1</td><td>32</td><td>79.6</td><td>79.6</td><td>2.03</td><td>2.03</td><td>84.8k</td><td>84.8k</td></tr><tr><td></td><td>4</td><td>128</td><td>81.0</td><td>80.9</td><td>5.21</td><td>4.66</td><td>22.5k</td><td>21.2k</td></tr><tr><td></td><td>8</td><td>256</td><td>80.7</td><td>80.2</td><td>6.74</td><td>6.81</td><td>12.1k</td><td>10.6k</td></tr><tr><td></td><td>16</td><td>512</td><td>80.6</td><td>N/A</td><td>7.33</td><td>N/A</td><td>6.95k</td><td>5.30k</td></tr><tr><td></td><td>32</td><td>1.02k</td><td>80.3</td><td>N/A</td><td>8.43</td><td>N/A</td><td>4.29k</td><td>2.65k</td></tr><tr><td>transformer</td><td>1</td><td>2.05k</td><td>27.2</td><td>27.2</td><td>1.60</td><td>1.60</td><td>1.55M</td><td>1.55M</td></tr><tr><td></td><td>16</td><td>32.8k</td><td>27.4</td><td>27.3</td><td>1.60</td><td>1.60</td><td>108k</td><td>99.0k</td></tr><tr><td></td><td>32</td><td>65.5k</td><td>27.3</td><td>27.0</td><td>1.59</td><td>1.61</td><td>58.9k</td><td>49.5k</td></tr><tr><td></td><td>64</td><td>131k</td><td>27.6</td><td>26.7</td><td>1.59</td><td>1.63</td><td>33.9k</td><td>24.8k</td></tr><tr><td></td><td>128</td><td>262k</td><td>27.4</td><td>N/A</td><td>1.59</td><td>N/A</td><td>21.4k</td><td>12.1k</td></tr><tr><td>yolo</td><td>1</td><td>16</td><td>80.2</td><td>80.2</td><td>2.65</td><td>2.65</td><td>207k</td><td>207k</td></tr><tr><td></td><td>16</td><td>256</td><td>81.5</td><td>81.4</td><td>2.63</td><td>2.66</td><td>15.9k</td><td>12.9k</td></tr><tr><td></td><td>32</td><td>512</td><td>81.3</td><td>80.5</td><td>2.61</td><td>2.81</td><td>9.27k</td><td>6.47k</td></tr><tr><td></td><td>64</td><td>1.02k</td><td>81.3</td><td>70.1</td><td>2.60</td><td>4.02</td><td>5.75k</td><td>3.23k</td></tr><tr><td></td><td>128</td><td>2.05k</td><td>81.4</td><td>N/A</td><td>2.57</td><td>N/A</td><td>4.07k</td><td>1.62k</td></tr></table>
+
+![](images/acbb7b4c8662acf63d9512e6cdbdf807391ceaccecb415bf3788a3b7bbaf5ce6.jpg)  
+Figure 5: Scale invariance for many learning rate schedules. Heat maps cover the space of exponential decay lr schedules for cifar10. At scale 16, validation accuracies for AdaScale align closely with results for single-batch training, with the space of $94 \%$ schedules growing moderately with AdaScale. With LSW, no schedule achieves $94 \%$ accuracy. On the right, direct $\mathtt { 1 r }$ search at scale 16 produces inferior results to AdaScale (here the total iterations, 3.28k, is the average total iterations among $94 \%$ AdaScale trials). Thus, AdaScale induces a superior family of schedules for scaled training. The white $^ \ast \times \cdot$ indicates the $\mathtt { l r }$ used for Figure 1.
+
+As a baseline for all benchmarks, we also evaluate linear scaling with warm-up (LSW). As inputs, LSW takes single-batch schedule $1 \mathbf { r } _ { \mathrm { S 1 } } = \mathtt { l } \mathbf { r }$ and single-batch steps $T _ { S 1 } = T _ { \mathrm { S I } }$ , where $\mathtt { l r }$ and $T _ { \mathrm { S I } }$ are the inputs to AdaScale. Our warm-up implementation closely follows Goyal et al. (2017). LSW trains for $\lceil T _ { S 1 } / S \rceil$ iterations, applying warm-up to the first $5 . 5 \%$ of iterations. During warm-up, the learning rate increases linearly from $\mathtt { l r } _ { S 1 } ( 0 )$ to $S \cdot 1 \mathbf { r } _ { S 1 } ( 0 )$ .
+
+Table 2 compares results for AdaScale and LSW. LSW consistently trains for fewer steps, but doing so comes at a cost. As $S$ grows larger, LSW consistently degrades model quality and sometimes diverges. For these divergent cases, we also tested doubling the warm-up duration to $11 \%$ of iterations, and training still diverged. In contrast, AdaScale preserves model quality for nearly all cases.
+
+As a final comparison, Figure 5 demonstrates AdaScale’s performance on cifar10 with many different $\mathtt { l r }$ schedules. We consider a $1 3 \times 1 3$ grid of exponential decay schedules and plot contours of resulting validation accuracy. At scale 16, AdaScale results align with accuracies for single-batch training, illustrating that AdaScale is approximately scale-invariant for many schedules. Moreover, AdaScale convincingly outperforms direct search over exponential decay schedules for scaled SGD at $S { = } 1 6$ . For training at scale, AdaScale provides a more natural learning rate parameterization.
+
+# 5 SCALE-INVARIANT CONVERGENCE BOUND
+
+We now present convergence bounds that formalize the approximate scale invariance of AdaScale. The bounds provide identical convergence guarantees for all scales, meaning that in terms of upper bounds on training loss, AdaScale is scale invariant. For comparison, we include an analogous bound for the linear scaling rule. Qualitatively, the bounds agree closely with our empirical results.
+
+Let us define $F ^ { * } = \mathrm { m i n } _ { \mathbf { w } } F ( \mathbf { w } )$ . Our analysis requires a few assumptions that are typical of SGD analysis of non-convex problems (see, for example, (Lei et al., 2017; Yuan et al., 2019)):
+
+Assumption 1 ( $\alpha$ -Polyak-Łojasiewicz). For some $\alpha > 0$ , $\begin{array} { r } { F ( \mathbf { w } ) - F ^ { * } \leq \frac { 1 } { 2 \alpha } \left\| \nabla F ( \mathbf { w } ) \right\| ^ { 2 } } \end{array}$ for all w.
+
+Assumption 2 ( $\beta$ -smooth). For some $\beta > 0$ , $\| \nabla F ( \mathbf { w } ) - \nabla F ( \mathbf { w } ^ { \prime } ) \| \leq \beta \| \mathbf { w } - \mathbf { w } ^ { \prime } \|$ for all w, $\mathbf { w } ^ { \prime }$ .
+
+Assumption 3 (Bounded variance). There exists a $V \geq 0$ such that $\sigma ^ { 2 } ( \mathbf { w } ) \leq V$ for all w.
+
+We emphasize that we do not assume convexity. The PL condition, which is perhaps our strongest assumption, is proven to hold for some nonlinear neural networks (Charles & Papailiopoulos, 2018).
+
+We consider constant lr schedules, which result in simple and instructive bounds. To provide context for the AdaScale result, we first present a straightforward bound for single-batch training:
+
+Theorem 1 (Single-batch SGD bound). Given Assumptions 1, 2, 3 and $\eta \in ( 0 , 2 \beta ^ { - 1 } )$ , consider Algorithm $^ { l }$ with $S = 1$ and $\boldsymbol { \mathbf { \rho } } _ { 1 \boldsymbol { \mathbf { r } } ( t ) } = \boldsymbol { \eta }$ . Defining $\gamma = \eta \alpha ( 2 - \eta \beta )$ and $\begin{array} { r } { \Delta = \frac { 1 } { 2 \gamma } \dot { \eta } ^ { 2 } \beta V } \end{array}$ , we have
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ F ( \mathbf { w } _ { T } ) - F ^ { * } \right] \leq ( 1 - \gamma ) ^ { T } \left[ F ( \mathbf { w } _ { 0 } ) - F ^ { * } \right] + \Delta . } \end{array}
+$$
+
+The bound describes two important characteristics of the single-batch algorithm. First, the suboptimality converges in expectation to at most $\Delta$ . Second, convergence to $\Delta + \epsilon$ requires at most
+
+$\lceil \log ( ( F ( \mathbf { w } _ { 0 } ) - F ^ { * } ) \epsilon ^ { - 1 } ) / \log ( ( 1 - \gamma ) ^ { - 1 } ) \rceil$ iterations. We note similar bounds exist, under a stronger variance assumption (Karimi et al., 2016; Reddi et al., 2016; De et al., 2017; Yin et al., 2018).
+
+Importantly, our AdaScale bound converges to this same $\Delta$ for all practical values of $S$ :
+
+Theorem 2 (AdaScale bound). Define $\gamma , \Delta$ as in Theorem 1. Given Assumptions 1, 2, 3, $S \le \gamma ^ { - 1 }$ and $\eta \in ( 0 , 2 \beta ^ { - 1 } )$ , define $\mathbf { w } _ { T }$ as the result of Algorithm 2 with $\boldsymbol { \mathbf { \rho } } _ { 1 \boldsymbol { \mathbf { r } } ( t ) } = \boldsymbol { \eta }$ and scale $S$ . Then
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ F ( \mathbf { w } _ { T } ) - F ^ { * } \right] \leq ( 1 - \gamma ) ^ { T _ { \mathrm { S I } } } \left[ F ( \mathbf { w } _ { 0 } ) - F ^ { * } \right] + \Delta . } \end{array}
+$$
+
+This bound for AdaScale is scale invariant, as it does not depend on $S$ . Like single-batch SGD, the suboptimality converges in expectation to at most $\Delta$ , but AdaScale achieves this for all scales. In addition, AdaScale speeds up training by a factor r¯ = 1T PT −1t=0 rt. That is, convergence to ∆ +  requires at most $\big \lceil \bar { r } ^ { - 1 } \log ( ( F ( \mathbf { w } _ { 0 } ) - F ^ { * } ) \epsilon ^ { - 1 } ) / \log ( ( 1 - \gamma ) ^ { - 1 } ) \big \rceil$ iterations (since $T _ { \mathrm { S I } } \leq \tau _ { T } = \bar { r } T ,$ ).
+
+As a final comparison, we provide an analogous bound for linear scaling, which is not scale invariant:
+
+Theorem 3 (Bound for linear scaling rule). Define $\gamma$ and $\Delta$ as in Theorem 1. Given Assumptions $^ { l }$ , 2, 3, $S \le \gamma ^ { - 1 }$ , and $\eta \in ( 0 , 2 ( S \beta ) ^ { - 1 } )$ , consider Algorithm $I$ with $\mathbf { 1 r } ( t ) = S \eta$ . We have
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ F ( \mathbf { w } _ { T } ) - F ^ { * } \right] \leq \left( 1 - \gamma \cdot \left( \frac { 2 - S \eta \beta } { 2 - \eta \beta } \right) \right) ^ { S T } \left[ F ( \mathbf { w } _ { 0 } ) - F ^ { * } \right] + \left( \frac { 2 - \eta \beta } { 2 - S \eta \beta } \right) \Delta . } \end{array}
+$$
+
+Unlike Theorem 2, this bound converges to a value that increases with $S$ . In addition, a smaller range of learning rates guarantees convergence. In practical terms, this means that linear scaling often leads to worse model quality and greater risk of divergence, especially for large $S$ . These differences appear throughout our empirical comparisons in $\ S 4$ .
+
+Finally, we note both Theorem 2 and Theorem 3 require that $S \le \gamma ^ { - 1 }$ . For practical problems, $\gamma$ is small, and we can safely ignore this constraint. Otherwise single batch training would converge quickly, due to Theorem 1, and smaller scales would result in fast training.
+
+# 6 RELATION TO PRIOR WORK
+
+While linear scaling with warm-up is perhaps the most popular scaling rule, researchers have considered a few alternative strategies. “Square root learning rate scaling” (Krizhevsky, 2014; Li et al., 2014; Hoffer et al., 2017; You et al., 2018) multiplies learning rates by the square root of the batch size increase. Across scales, this preserves the covariance of the SGD update. Establishing this invariant remains poorly justified, however, and often root scaling degrades model quality in practice (Goyal et al., 2017; Golmant et al., 2018; Jastrz˛ebski et al., 2018). AdaScale adapts learning rates by making $\eta _ { t } \mathbb { E } \left[ \| \bar { \mathbf { g } } _ { t } \| ^ { 2 } \right]$ invariant across scales, which results in our scale-invariant bound from $\ S 5$ . Finally, we might also consider model-specific scaling rules, such as LARS for CNNs (You et al., 2017). AdaScale solves the general problem (P1), making AdaScale applicable to many models.
+
+Many prior works have also considered the role of gradient variance in SGD. McCandlish et al. (2018) study the impact of gradient variance on scaling efficiency. These general findings also apply to AdaScale, as gradient variance similarly determines AdaScale’s efficiency. Much like AdaScale, Johnson $\&$ Guestrin (2018) also adapt learning rates to lower amounts of gradient variance—in this case when using SGD with importance sampling. Because the variance reduction is relatively small in this setting, however, distributed training can have far greater impact on training times. Lastly, many algorithms also adapt to gradient moments for improved training, given a fixed amount of variance—see (Schaul et al., 2013; Kingma & Ba, 2015; Balles & Hennig, 2018), just to name a few. AdaScale adapts learning rates across scales, which correspond to different amounts of gradient variance. Perhaps future algorithms will combine approaches in order to achieve both goals.
+
+# 7 DISCUSSION
+
+SGD is not perfectly parallelizable. Unsurprisingly, the linear scaling rule can fail at large scales. In contrast, AdaScale accepts sublinear speedups in order to better preserve model quality. What do the speed-ups from AdaScale tell us about the scaling efficiency of SGD in general? For many problems, such as imagenet with batch size $3 2 . 8 \mathrm { k }$ , AdaScale establishes lower bounds on SGD’s scaling efficiency. An important remaining question is whether AdaScale is optimally efficient, or if other practical algorithms can achieve similar scale invariance with fewer iterations.
+
+AdaScale provides a useful new parameterization of learning rate schedules for large-batch SGD. We provide a simple lr schedule, which AdaScale adapts to learning rates for scaled training. From this, warm-up behavior emerges naturally, which produces quality models for many problems and scales. Even in elastic scaling settings, AdaScale adapts successfully to the state of training. Given these appealing qualities, it seems important to further study such learning rate schedules.
+
+Based on our empirical results, as well as the algorithm’s practicality and theoretical justification, we believe that AdaScale is valuable for speeding up training in practice.
+
+# REFERENCES
+
+D. Amodei, R. Anubhai, E. Battenberg, C. Case, J. Casper, B. Catanzaro, J. Chen, M. Chrzanowski, A. Coates, G. Diamos, E. Elsen, J. H. Engel, L. Fan, C. Fougner, T. Han, A. Y. Hannun, B. Jun, P. LeGresley, L. Lin, S. Narang, A. Y. Ng, S. Ozair, R. Prenger, J. Raiman, S. Satheesh, D. Seetapun, S. Sengupta, Y. Wang, Z. Wang, C. Wang, B. Xiao, D. Yogatama, J. Zhan, and Z. Zhu. Deep speech 2: End-to-end speech recognition in English and Mandarin. In Proceedings of the 33rd International Conference on Machine Learning, 2016.   
+L. Balles and P. Hennig. Dissecting Adam: The sign, magnitude and variance of stochastic gradients. In Proceedings of the 35th International Conference on Machine Learning, 2018.   
+Z. Charles and D. Papailiopoulos. Stability and generalization of learning algorithms that converge to global optima. In Proceedings of the 35th International Conference on Machine Learning, 2018.   
+S. De, A. Yadav, D. Jacobs, and T. Goldstein. Automated inference with adaptive batches. In Proceedings of the 20th International Conference on Artificial Intelligence and Statistics, 2017.   
+J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In IEEE Conference on Computer Vision and Pattern Recognition, 2009.   
+A. Devarakonda, M. Naumov, and M. Garland. Adabatch: Adaptive batch sizes for training deep neural networks. arXiv:1712.02029, 2017.   
+M. Everingham, L. Van Gool, C. K. I. Williams, J. Winn, and A. Zisserman. The pascal visual object classes (VOC) challenge. International Journal of Computer Vision, 88(2):303–338, 2010.   
+N. Golmant, N. Vemuri, Z. Yao, V. Feinberg, A. Gholami, K. Rothauge, M. W. Mahoney, and J. Gonzalez. On the computational inefficiency of large batch sizes for stochastic gradient descent. arXiv:1811.12941, 2018.   
+P. Goyal, P. Dollár, R. Girshick, P. Noordhuis, L. Wesolowski, A. Kyrola, A. Tulloch, Y. Jia, and K. He. Accurate, large minibatch SGD: Training ImageNet in one hour. arXiv:1706.02677, 2017.   
+K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, 2016a.   
+K. He, X. Zhang, S. Ren, and J. Sun. Identity mappings in deep residual networks. In European conference on computer vision, 2016b.   
+E. Hoffer, I. Hubara, and D. Soudry. Train longer, generalize better: Closing the generalization gap in large batch training of neural networks. In Advances in Neural Information Processing Systems 30, 2017.   
+P. Jain, S. M. Kakade, R. Kidambi, P. Netrapalli, and A. Sidford. Parallelizing stochastic gradient descent for least squares regression: Mini-batching, averaging, and model misspecification. Journal of Machince Learning Research, 18(223):1–42, 2018.   
+S. Jastrz˛ebski, Z. Kenton, D. Arpit, N. Ballas, A. Fischer, Y. Bengio, and A. J. Storkey. Three factors influencing minima in SGD. In Proceedings of the 27th International Conference on Artificial Neural Networks, 2018.   
+T. B. Johnson and C. Guestrin. Training deep models faster with robust, approximate importance sampling. In Advances in Neural Information Processing Systems 31, 2018.   
+H. Karimi, J. Nutini, and M. Schmidt. Linear convergence of gradient and proximal-gradient methods under the polyak-łojasiewicz condition. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, 2016.   
+D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. In Proceedings of the 3rd International Conference on Learning Representations, 2015.   
+P. E. Kloeden and E. Platen. Numerical Solution of Stochastic Differential Equations. Springer, 1992.   
+A. Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.   
+A. Krizhevsky. One weird trick for parallelizing convolutional neural networks. arXiv:1404.5997, 2014.   
+L. Lei, C. Ju, J. Chen, and M. I. Jordan. Nonconvex finite-sum optimization via SCSG methods. In Advances in Neural Information Processing Systems 30, 2017.   
+M. Li, T. Zhang, Y. Chen, and A. J. Smola. Efficient mini-batch training for stochastic optimization. In Proceedings of the 20th ACM SIGKDD Interational Conference on Knowledge Discovery and Data Mining, 2014.   
+H. Lin, H. Zhang, Y. Ma, T. He, Z. Zhang, S. Zha, and M. Li. Dynamic mini-batch SGD for elastic distributed training: Learning in the limbo of resources. arXiv:1904.12043, 2019.   
+S. Ma, R. Bassily, and M. Belkin. The power of interpolation: Understanding the effectiveness of SGD in modern over-parametrized learning. In Proceedings of the 35th International Conference on Machine Learning, 2018.   
+S. McCandlish, J. Kaplan, D. Amodei, and OpenAI Dota Team. An empirical model of large-batch training. arXiv:1812.06162, 2018.   
+V. Panayotov, G. Chen, D. Povey, and S. Khudanpur. Librispeech: An ASR corpus based on public domain audio books. In IEEE International Conference on Acoustics, Speech and Signal Processing, 2015.   
+S. J. Reddi, A. Hefny, S. Sra, B. Póczoós, and A. Smola. Stochastic variance reduction for nonconvex optimization. In Proceedings of the 33rd International Conference on Machine Learning, 2016.   
+J. Redmon and A. Farhadi. YOLOv3: An incremental improvement. arXiv:1804.02767, 2018.   
+T. Schaul, S. Zhang, and Y. LeCun. No more pesky learning rates. In Proceedings of the 30th International Conference on Machine Learning, 2013.   
+C. J. Shallue, J. Lee, J. Antognini, J. Sohl-Dickstein, R. Frostig, and G. E. Dahl. Measuring the effects of data parallelism on neural network training. Journal of Machince Learning Research, 20(112):1–49, 2019.   
+S. Smith, P. Kindermans, C. Ying, and Q. V. Le. Don’t decay the learning rate, increase the batch size. In Proceedings of the 6th International Conference on Learning Representations, 2018.   
+A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems 31, 2017.   
+D. Yin, A. Pananjady, M. Lam, D. Papailiopoulos, K. Ramchandran, and P. Bartlett. Gradient diversity: A key ingredient for scalable distributed learning. In Proceedings of the 21st International Conference on Artificial Intelligence and Statistics, 2018.   
+Y. You, I. Gitman, and B. Ginsburg. Large batch training of convolutional networks. arXiv:1708.03888, 2017.   
+Y. You, J. Hseu, C. Ying, J. Demmel, K. Keutzer, and C.-J. Hsieh. Large-batch training for LSTM and beyond. In NeurIPS Workshop on Systems for ML and Open Source Software, 2018.   
+Z. Yuan, Y. Yan, R. Jin, and T. Yang. Stagewise training accelerates convergence of testing error over sgd. In Advances in Neural Information Processing Systems 32, 2019.   
+H. Zhang, M. Cisse, Y. N. Dauphin, and D. Lopez-Paz. Mixup: Beyond empirical risk minimization. In International Conference on Learning Representations, 2018.   
+Z. Zhang, T. He, H. Zhang, Z. Zhang, J. Xie, and M. Li. Bag of freebies for training object detection neural networks. arXiv:1902.04103, 2019.
+
+# A PROOFS
+
+In this appendix, we prove the results from $\ S 5$ and $\ S 3$ . We first prove a lemma in $\ S \mathrm { A } . 1$ , which we apply in the proofs. We prove Theorem 1 in $\ S \mathrm { A } . 2$ , Theorem 2 in $\ S \mathrm { A } . 3$ , and Theorem 3 in $\ S _ { \mathrm { A } . 4 }$ . We also prove Proposition 1 in $\ S _ { \mathrm { A } . 5 }$ and Proposition 2 in $\ S \mathrm { A } . 6$ .
+
+# A.1 KEY LEMMA
+
+Lemma 1. Given Assumptions 1, 2, 3 and $\eta \in ( 0 , 2 \beta ^ { - 1 } )$ , define $\gamma = \eta \alpha ( 2 - \eta \beta )$ and $\begin{array} { r } { \Delta = \frac { 1 } { 2 \gamma } \eta ^ { 2 } \beta V } \end{array}$ . Consider Algorithm 2 with $\boldsymbol { \mathbf { \rho } } _ { 1 \boldsymbol { \mathbf { r } } ( t ) } = \boldsymbol { \eta }$ . For all iterations $t$ , we have
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ F ( \mathbf { w } _ { t } ) - F ^ { * } \right] \leq \left[ F ( \mathbf { w } _ { 0 } ) - F ^ { * } \right] \prod _ { t ^ { \prime } = 0 } ^ { t - 1 } ( 1 - r _ { t ^ { \prime } } \gamma ) + \Delta . } \end{array}
+$$
+
+Proof. We prove this by induction. To simplify notation, let us define $\tilde { F } ( \mathbf { w } ) = F ( \mathbf { w } ) - F ^ { * }$ . For $t = 0$ , we have
+
+$$
+\begin{array} { r } { \mathbb { E } [ \tilde { F } ( \mathbf { w } _ { 0 } ) ] = \tilde { F } ( \mathbf { w } _ { 0 } ) \leq \tilde { F } ( \mathbf { w } _ { 0 } ) \prod _ { t ^ { \prime } = 0 } ^ { - 1 } ( 1 - r _ { t ^ { \prime } } \gamma ) + \Delta . } \end{array}
+$$
+
+Note we are using the convention $\textstyle \prod _ { i = 0 } ^ { - 1 } x _ { i } = 1$ . For $t \geq 1$ , assume the inductive hypothesis
+
+$$
+\mathbb { E } [ \tilde { F } ( \mathbf { w } _ { t - 1 } ) ] \leq \tilde { F } ( \mathbf { w } _ { 0 } ) \prod _ { t ^ { \prime } = 0 } ^ { t - 2 } ( 1 - r _ { t ^ { \prime } } \gamma ) + \Delta .
+$$
+
+Applying Assumption 2 (smoothness) and the update equation $\mathbf { w } _ { t } = \mathbf { w } _ { t - 1 } - r _ { t - 1 } \eta \bar { \mathbf { g } } _ { t - 1 }$ , we have
+
+$$
+\begin{array} { r l r } & { } & { \tilde { F } ( \mathbf { w } _ { t } ) \leq \tilde { F } ( \mathbf { w } _ { t - 1 } ) + \langle \nabla F ( \mathbf { w } _ { t - 1 } ) , \mathbf { w } _ { t } - \mathbf { w } _ { t - 1 } \rangle + \frac { \beta } { 2 } \left\| \mathbf { w } _ { t } - \mathbf { w } _ { t - 1 } \right\| ^ { 2 } } \\ & { } & { = \tilde { F } ( \mathbf { w } _ { t - 1 } ) - r _ { t - 1 } \eta \langle \nabla F ( \mathbf { w } _ { t - 1 } ) , \bar { \mathbf { g } } _ { t - 1 } \rangle + r _ { t - 1 } ^ { 2 } \eta ^ { 2 } \frac { \beta } { 2 } \left\| \bar { \mathbf { g } } _ { t - 1 } \right\| ^ { 2 } . } \end{array}
+$$
+
+Taking the expectation with respect to the $S$ random batches from step $t$ , we have
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ \tilde { F } ( \mathbf { w } _ { t } ) \ | \ \mathbf { w } _ { t - 1 } \right] \leq \tilde { F } ( \mathbf { w } _ { t - 1 } ) - r _ { t - 1 } \eta \left. \nabla F ( \mathbf { w } _ { t - 1 } ) \right. ^ { 2 } + r _ { t - 1 } ^ { 2 } \eta ^ { 2 } \frac { \beta } { 2 } \mathbb { E } \left[ \left. \bar { \mathbf { g } } _ { t - 1 } \right. ^ { 2 } | \ \mathbf { w } _ { t - 1 } \right] . } \end{array}
+$$
+
+Now taking the expectation with respect to the distribution of $\mathbf { w } _ { t - 1 }$ , it follows that
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ \tilde { F } ( \mathbf { w } _ { t } ) \right] \leq \mathbb { E } \left[ \tilde { F } ( \mathbf { w } _ { t - 1 } ) \right] - r _ { t - 1 } \eta \mathbb { E } \left[ \left. \nabla F ( \mathbf { w } _ { t - 1 } ) \right. ^ { 2 } \right] + r _ { t - 1 } ^ { 2 } \eta ^ { 2 } \frac { \beta } { 2 } \mathbb { E } \left[ \left. \bar { \mathbf { g } } _ { t - 1 } \right. ^ { 2 } \right] . } \end{array}
+$$
+
+For the last term, we have
+
+$$
+\begin{array} { r l } { \mathbb { E } \left[ \left. \bar { \mathbf { g } } _ { t - 1 } \right. ^ { 2 } \right] = \mathbb { E } \left[ \left. \left( \bar { \mathbf { g } } _ { t - 1 } - \nabla F ( \mathbf { w } _ { t - 1 } ) \right) + \nabla F ( \mathbf { w } _ { t - 1 } ) \right. ^ { 2 } \right] } & { } \\ & { = \mathbb { E } \left[ \left. \bar { \mathbf { g } } _ { t - 1 } - \nabla F ( \mathbf { w } _ { t - 1 } ) \right. ^ { 2 } + \left. \nabla F ( \mathbf { w } _ { t - 1 } ) \right. ^ { 2 } \right] } \\ & { = \mathbb { E } \left[ \frac { 1 } { S } \sigma ^ { 2 } ( \mathbf { w } _ { t - 1 } ) + \left. \nabla F ( \mathbf { w } _ { t - 1 } ) \right. ^ { 2 } \right] } \\ & { = \frac { 1 } { r _ { t - 1 } } \mathbb { E } \left[ \sigma ^ { 2 } ( \mathbf { w } _ { t - 1 } ) + \left. \nabla F ( \mathbf { w } _ { t - 1 } ) \right. ^ { 2 } \right] } \\ & { \leq \frac { 1 } { r _ { t - 1 } } \left( \mathbb { E } \left[ \left. \nabla F ( \mathbf { w } _ { t - 1 } ) \right. ^ { 2 } \right] + V \right) . } \end{array}
+$$
+
+Combining (3) with (2), we have
+
+$$
+\begin{array} { r l } & { \mathbb { E } \left[ \tilde { F } ( \mathbf { w } _ { t } ) \right] \leq \mathbb { E } \left[ \tilde { F } ( \mathbf { w } _ { t - 1 } ) \right] - r _ { t - 1 } \eta ( 1 - \eta _ { 2 } ^ { \beta } ) \mathbb { E } \left[ \left. \nabla F ( \mathbf { w } _ { t - 1 } ) \right. ^ { 2 } \right] + r _ { t - 1 } \eta ^ { 2 } \frac { \beta } { 2 } V } \\ & { \qquad \leq ( 1 - r _ { t - 1 } \gamma ) \mathbb { E } \left[ \tilde { F } ( \mathbf { w } _ { t - 1 } ) \right] + r _ { t - 1 } \gamma \Delta . } \end{array}
+$$
+
+In this last step, we applied Assumption 1 (PL condition) and plugged in definitions for $\gamma$ and $\Delta$
+
+To complete the proof, we apply (1):
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { E } \big [ \tilde { F } ( \mathbf { w } _ { t } ) \big ] \leq \big ( 1 - r _ { t - 1 } \gamma \big ) \left( \tilde { F } ( \mathbf { w } _ { 0 } ) \prod _ { t ^ { \prime } = 0 } ^ { t - 2 } ( 1 - r _ { t ^ { \prime } } \gamma ) + \Delta \right) + r _ { t - 1 } \gamma \Delta } \\ { \displaystyle = \tilde { F } ( \mathbf { w } _ { 0 } ) \prod _ { t ^ { \prime } = 0 } ^ { t - 1 } ( 1 - r _ { t ^ { \prime } } \gamma ) + \Delta . } \end{array}
+$$
+
+# A.2 PROOF OF THEOREM 1
+
+Theorem 1 (Single-batch SGD bound). Given Assumptions 1, 2, 3 and $\eta \in ( 0 , 2 \beta ^ { - 1 } )$ , consider Algorithm $^ { l }$ with $S = 1$ and $\boldsymbol { \mathbf { \rho } } _ { 1 \boldsymbol { \mathbf { r } } ( t ) } = \boldsymbol { \eta }$ . Defining $\gamma = \eta \alpha ( 2 - \eta \beta )$ and $\begin{array} { r } { \Delta = \frac { 1 } { 2 \gamma } \dot { \eta } ^ { 2 } \beta V } \end{array}$ , we have
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ F ( \mathbf { w } _ { T } ) - F ^ { * } \right] \leq ( 1 - \gamma ) ^ { T } \left[ F ( \mathbf { w } _ { 0 } ) - F ^ { * } \right] + \Delta . } \end{array}
+$$
+
+Proof. The theorem is a special case of Lemma 1. In particular, Algorithm 1 with inputs $\boldsymbol { \mathbf { \rho } } _ { 1 \boldsymbol { \mathbf { r } } ( t ) } = \eta$ , $S = 1$ , and $T$ iterations is equivalent to Algorithm 2 with $T _ { \mathrm { S I } } = T$ and the same scale and learning rate inputs. This follows from the fact that $r _ { t } = 1$ for all iterations of AdaScale when $S = 1$ . Thus, we can obtain the result by plugging $t = T$ into the bound from Lemma 1. □
+
+# A.3 PROOF OF THEOREM 2
+
+Theorem 2 (AdaScale bound). Define $\gamma , \Delta$ as in Theorem $^ { l }$ . Given Assumptions 1, 2, 3, $S \le \gamma ^ { - 1 }$ , and $\eta \in ( 0 , 2 \beta ^ { - 1 } )$ , define ${ \bf w } _ { T }$ as the result of Algorithm 2 with $\boldsymbol { \mathbf { \rho } } _ { 1 \boldsymbol { \mathbf { r } } ( t ) } = \boldsymbol { \eta }$ and scale $S$ . Then
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ F ( \mathbf { w } _ { T } ) - F ^ { * } \right] \leq ( 1 - \gamma ) ^ { T _ { \mathrm { S I } } } \left[ F ( \mathbf { w } _ { 0 } ) - F ^ { * } \right] + \Delta . } \end{array}
+$$
+
+Proof. Let $T$ denote the total iterations for Algorithm 2. Applying Lemma 1, we have
+
+$$
+\mathbb { E } \left[ F ( \mathbf { w } _ { t } ) - F ^ { * } \right] \leq \left( F ( \mathbf { w } _ { 0 } ) - F ^ { * } \right) \prod _ { t ^ { \prime } = 0 } ^ { T - 1 } ( 1 - r _ { t ^ { \prime } } \gamma ) + \Delta .
+$$
+
+Now note that for any $r \geq 1$ and $x \in [ 0 , 1 ]$ , we have
+
+$$
+1 - r x \leq ( 1 - x ) ^ { r } .
+$$
+
+This holds because for any $r \geq 1$ and $x \in [ 0 , 1 ]$ , the function $( 1 - x ) ^ { r }$ is convex in $x$ , and $1 - r x$ is tangent to this function at $x = 0$ . Thus,
+
+$$
+\prod _ { t ^ { \prime } = 0 } ^ { T - 1 } ( 1 - r _ { t ^ { \prime } } \gamma ) \leq ( 1 - \gamma ) ^ { \sum _ { t ^ { \prime } = 0 } ^ { T - 1 } r _ { t ^ { \prime } } } .
+$$
+
+Note that this requires $1 - r _ { t } \gamma \ge 0$ for all $t$ , which is true because $r _ { t } \le S \le \gamma ^ { - 1 }$ . Now plugging (7) into (5),
+
+$$
+\begin{array} { r l } & { \mathbb { E } \left[ F ( \mathbf { w } _ { t } ) - F ^ { * } \right] \leq ( F ( \mathbf { w } _ { 0 } ) - F ^ { * } ) ( 1 - \gamma ) ^ { \sum _ { t ^ { \prime } = 0 } ^ { T - 1 } r _ { t ^ { \prime } } } + \Delta } \\ & { \qquad \leq ( F ( \mathbf { w } _ { 0 } ) - F ^ { * } ) ( 1 - \gamma ) ^ { T _ { \mathrm { S I } } } + \Delta . } \end{array}
+$$
+
+In the last step, we use the stopping condition of Algorithm 2 $\begin{array} { r } { ( T _ { \mathrm { S I } } \leq \tau _ { T } = \sum _ { t = 0 } ^ { T - 1 } r _ { t } ) } \end{array}$
+
+# A.4 PROOF OF THEOREM 3
+
+Theorem 3 (Bound for linear scaling rule). Define $\gamma$ and $\Delta$ as in Theorem 1. Given Assumptions $^ { l }$ , 2, 3, $S \le \gamma ^ { - 1 }$ , and $\eta \in ( 0 , 2 ( S \beta ) ^ { - 1 } )$ , consider Algorithm $I$ with $\mathbf { 1 r } ( t ) = S \eta$ . We have
+
+$$
+\begin{array} { r } { \mathbb { E } \left[ F ( \mathbf { w } _ { T } ) - F ^ { * } \right] \leq \left( 1 - \gamma \cdot \left( \frac { 2 - S \eta \beta } { 2 - \eta \beta } \right) \right) ^ { S T } \left[ F ( \mathbf { w } _ { 0 } ) - F ^ { * } \right] + \left( \frac { 2 - \eta \beta } { 2 - S \eta \beta } \right) \Delta . } \end{array}
+$$
+
+Proof. We reduce the theorem to a special case of Theorem 1. Define $\tilde { \mathbf { x } } = ( \tilde { \mathbf { x } } ^ { ( 1 ) } , \dots , \tilde { \mathbf { x } } ^ { ( S ) } )$ , where $\tilde { \mathbf { x } } ^ { ( i ) } \sim \mathcal { X }$ for each $i \in [ S ]$ , and $\tilde { \mathbf { x } } ^ { ( 1 ) } , \ldots , \tilde { \mathbf { x } } ^ { ( S ) }$ are jointly independent. Denote by $\tilde { \mathcal X }$ the distribution of $\tilde { \mathbf { x } }$ . Also define
+
+$$
+\tilde { f } ( \mathbf { w } , \tilde { \mathbf { x } } ) = \frac { 1 } { S } \sum _ { i = 1 } ^ { S } f ( \mathbf { w } , \tilde { \mathbf { x } } ^ { ( i ) } ) .
+$$
+
+It follows that for any w,
+
+$$
+\mathbb { E } _ { \tilde { \mathbf { x } } } \left[ \lVert \nabla \tilde { f } ( \mathbf { w } , \tilde { \mathbf { x } } ) - \nabla F ( \mathbf { w } ) \rVert ^ { 2 } \right] = \frac { 1 } { S } \sigma ^ { 2 } ( \mathbf { w } ) \le \frac { V } { S } .
+$$
+
+The algorithm described in Theorem 3 is identical to running Algorithm 1 with scale 1, batch distribution $\tilde { \mathcal X }$ , loss $\tilde { f }$ , learning rate $\mathbf { 1 r } ( t ) = S \eta$ , and variance upper bound $\frac { V } { S }$ . Plugging these values into Theorem 1, we have
+
+$$
+\begin{array} { r } { \displaystyle \mathbb { E } \left[ F ( \mathbf { w } _ { T } ) - F ^ { * } \right] \leq ( 1 - S \eta \alpha ( 2 - S \eta \beta ) ) ^ { T } [ F ( \mathbf { w } _ { 0 } ) - F ^ { * } ] + \frac { S \eta \beta V S ^ { - 1 } } { 2 \alpha \left( 2 - S \eta \beta \right) } } \\ { = \left( 1 - S \gamma \cdot \left( \frac { 2 - S \eta \beta } { 2 - \eta \beta } \right) \right) ^ { T } \left[ F ( \mathbf { w } _ { 0 } ) - F ^ { * } \right] + \left( \frac { 2 - \eta \beta } { 2 - S \eta \beta } \right) \Delta } \\ { \leq \left( 1 - \gamma \cdot \left( \frac { 2 - S \eta \beta } { 2 - \eta \beta } \right) \right) ^ { S T } \left[ F ( \mathbf { w } _ { 0 } ) - F ^ { * } \right] + \left( \frac { 2 - \eta \beta } { 2 - S \eta \beta } \right) \Delta . } \end{array}
+$$
+
+The last step follows from (6).
+
+# A.5 PROOF OF PROPOSITION 1
+
+Proposition 1 (Scale-invariant SGD for deterministic gradients). If $\sigma ^ { 2 } ( \mathbf { w } ) = 0$ for all $\mathbf { w } \in \mathbb { R } ^ { d }$ , then applying identity scaling to Algorithm 1 results in a scale-invariant algorithm.
+
+Proof. Since the gradient variance is zero, the compute_gradient function returns $\nabla F ( \mathbf { w } _ { t } )$ , which does not depend on $S$ . Thus, the algorithm does not depend on $S$ in this case, which implies that it is scale-invariant. □
+
+# A.6 PROOF OF PROPOSITION 2
+
+Proposition 2 (Scale-invariant SGD for extreme stochasticity). Consider fixed covariance matrix $\tilde { \Sigma } \in \mathbb S _ { + + } ^ { d }$ , learning rate value $\tilde { \eta } \in \mathbb { R } _ { > 0 }$ , and training duration $\tilde { T }$ . For a given $\nu \in \mathbb { R } _ { > 0 }$ , assume $\nabla _ { \mathbf { w } } { f } ( \mathbf { w } , \mathbf { x } ) \sim { \mathcal { N } } ( \nabla F ( \mathbf { w } ) , \nu \tilde { \Sigma } )$ , and apply linear scaling to Algorithm $^ { l }$ with $\mathbf { 1 } \mathbf { r } _ { S 1 } ( t ) = \nu ^ { - 1 } \tilde { \eta }$ and $T _ { S 1 } = \nu \tilde { T }$ . The resulting scaled SGD algorithm is scale-invariant in the limit $\nu \to + \infty$ .
+
+Proof. The scaled SGD algorithm runs for $\lceil \nu \tilde { T } / S \rceil$ iterations and follows the update rule
+
+$$
+\begin{array} { r } { \mathbf { w } _ { t + 1 } = \mathbf { w } _ { t } - \frac { S \tilde { \eta } } { \nu } \nabla F ( \mathbf { w } _ { t } ) + \frac { S \tilde { \eta } } { \nu } \pmb { \xi } _ { t } . } \end{array}
+$$
+
+Here $\xi _ { t }$ is normally distributed with $\mathbb { E } \left[ \pmb { \xi } _ { t } \right] = \mathbf { 0 }$ and $\begin{array} { r } { \mathrm { c o v } ( \pmb { \xi } _ { t } , \pmb { \xi } _ { t } ) = \frac { \nu } { S } \tilde { \pmb { \Sigma } } } \end{array}$ . In the limit $\nu \to + \infty$ , this difference equation converges to a stochastic differential equation on the interval $[ 0 , \tilde { \eta } \tilde { T } ]$ (Kloeden & Platen, 1992, Chapter 9):
+
+$$
+d \mathbf { w } = - \nabla F ( \mathbf { w } ) d t + ( \widetilde { \eta } \widetilde { \Sigma } ) ^ { 1 / 2 } d \mathbf { W } ( t ) , \quad \mathrm { w h e r e } \quad \mathbf { W } ( t ) \sim \mathcal { N } ( \mathbf { 0 } , \mathbf { I } ) .
+$$
+
+Since this SDE does not depend on $S$ , the algorithm is scale-invariant in this limit.
+
+# B ADDITIONAL DETAILS ON EMPIRICAL COMPARISONS
+
+This appendix provides additional details of our experiment set-up.
+
+# B.1 LEARNING RATE SCHEDULES
+
+We describe the $\mathtt { l r }$ schedules for each training benchmark in Table 3. We use two learning rate families: exponential decay and step decay. Using parameters $\eta _ { 0 } , \ d ,$ , and $w _ { i }$ , we define $\mathbf { 1 r } ( t ) = \eta _ { 0 } d ^ { ( t / T _ { S 1 } ) }$ for exponential decay families and $\ker ( t ) = \eta _ { 0 } d ^ { \sum _ { i } ^ { n } \mathbb { 1 } [ t > w _ { i } ] }$ for step decay families. Here $T _ { S 1 }$ denotes the total iterations for scale $S = 1$ . Note that in all cases, we use simple schedules and no warm-up.
+
+Table 3: Learning rate schedules for training benchmarks.   
+
+<table><tr><td>Benchmark</td><td>Learning rate famliy</td><td>m0</td><td>d</td><td>Wi</td></tr><tr><td>cifar10</td><td>Exponential decay</td><td>0.08</td><td>0.0133</td><td>N/A</td></tr><tr><td>imagenet</td><td>Step decay</td><td>0.1</td><td>0.1</td><td>150,240, 300,480, 400,640</td></tr><tr><td>speech</td><td>Exponential decay</td><td>1.4 ×10-3</td><td>0.05</td><td>N/A</td></tr><tr><td>transformer</td><td>Step decay</td><td>0.01</td><td>0.1</td><td>1,440,000</td></tr><tr><td>yolo</td><td>Step decay</td><td>2.5 ×10-4</td><td>0.1</td><td>160,000,180,000</td></tr></table>
+
+For imagenet and yolo, we used standard learning rate schedules from (Goyal et al., 2017) and (Zhang et al., 2019). For cifar10, speech, and transformer, we chose learning rate parameters, via hand-tuning, that approximately maximized model quality. This was necessary for speech and transformer, since our reference implementations train with the Adam optimizer (Kingma & Ba, 2015), and momentum-SGD requires different learning rate values.
+
+# B.2 WARM-UP IMPLEMENTATION
+
+Our warm-up procedure closely follows the strategy of Goyal et al. (2017). We apply warm-up for the first $5 . 5 \%$ of training iterations—we denote this number by $W _ { S }$ . During warm-up, the learning rate increases linearly, starting at the initial learning rate for single-batch training and finishing at $S$ times this value. After warm-up, we apply linear scaling to the single-batch schedule. Following Goyal et al. (2017), we modify this scaled schedule so that the total iterations, including warm-up, is proportional to $S ^ { - 1 }$ . For step-decay schedules, we omit the first $W _ { S }$ iterations after warm-up. For exponential decay schedules, we compress the scaled schedule by $W _ { S }$ iterations, using slightly faster decay.
+
+# B.3 BENCHMARK-SPECIFIC IMPLEMENTATION DETAILS
+
+Here we describe implementation details that are specific to each benchmark task.
+
+# B.3.1 cifar10
+
+We train ResNet-18 (preactivation) models (He et al., 2016b), using the standard training data split for CIFAR-10 (Krizhevsky, 2009). We use weight decay $= 5 \times 1 0 ^ { - 4 }$ . For batch normalization, we use parameters momentum $= 0 . 9 9 5$ and $\epsilon = 2 \stackrel { - } { \times } 1 0 ^ { - 5 }$ , and we do not train the batch normalization scaling parameters. We apply standard data augmentation during training. Specifically, we pad images to $4 0 \times 4 0$ and random crop to $3 2 \times 3 2$ , and we also apply random horizontal reflections.
+
+# B.3.2 imagenet
+
+For ImageNet classification (Deng et al., 2009), we train ResNet-50 models (He et al., 2016a). Our implementation closely follows the implementation of Goyal et al. (2017). We use stride2 convolutions on $3 \times 3$ layers. For each block’s final batch normalization layer, we initialize the batch norm scaling parameters to 0 (and we initialize to 1 everywhere else). We use weight decay parameter $1 0 ^ { - 4 }$ . Since each GPU processes 128 examples per batch, we use ghost batch normalization (Hoffer et al., 2017) with ghost batch size 32. We resize input images to $2 2 4 \times 2 2 4 \times 3$ . For data augmentation, we apply random cropping and left-right mirroring during training.
+
+# B.3.3 speech
+
+We use Amodei et al. (2016)’s Deep Speech 2 model architecture. The model consists of two 2D convolutional input layers, five bidirectional RNN layers, one fully connected layer, and softmax outputs. Each convolutional layer has 32 filters. The RNN layers use GRU cells with hidden size 800. We apply batch normalization to the inputs of each layer. The batch norm parameters are momentum $= \ 0 . 9 9 7$ and $\epsilon = 1 0 ^ { - 5 }$ . The loss is CTC loss. The inputs to the network are log spectrograms, which we compute using 20ms windows from audio waveforms sampled at $1 6 \mathrm { k H z }$ . The training data is the train-clean $- 1 0 0$ and $\mathtt { t r a i n - c l e a n - 3 6 0 }$ partitions of the OpenSLR LibriSpeech Corpus, which amounts to 460 hours of recorded speech. We evaluate models on the dev-clean partition.
+
+# B.3.4 transformer
+
+We train Transformer base models (Vaswani et al., 2017). We use dynamic batching with at most 256 tokens per example. In Table 2, the “batch size” is the maximum number of tokens processed per iteration. Our implementation closely follows that of Vaswani et al. (2017). Unlike Vaswani et al., we use only the final model for evaluation instead of the average of the last five checkpoints. We train on the WMT 2014 English-German dataset and evaluate on the newstest2014 test set.
+
+# B.3.5 yolo
+
+We train YOLOv3 models (Redmon & Farhadi, 2018). To achieve high mAP scores, we also apply mixup (Zhang et al., 2018) and class label smoothing, following (Zhang et al., 2019). We also use focal loss. We use batch normalization momentum $= 0 . 9$ and weight decay $= 5 \times 1 0 ^ { - 4 }$ . We resize input images to $4 1 6 \times 4 1 6$ (for both training and validation). We report mAP values at IOU threshold 0.5. We use the Pascal VOC 2007 trainval and 2012 trainval datasets for training and the 2007 test set for validation (Everingham et al., 2010). During training, we initialize the darknet-53 convolutional layers with weights trained on ImageNet.
+
+# B.4 MISCELLANEOUS
+
+In practice, wall time speed-ups also depend on system scaling efficiency. Since most aspects of system scaling relate orthogonally to the training algorithm, we limit our scope to algorithmic aspects of training.
+
+For Figure 5, one dimension defines initial value $\mathtt { l r } ( 0 )$ , and the second dimension specifies total decrease $\mathtt { l r } ( T _ { \mathrm { S I } } ) / \mathtt { l r } ( 0 )$ . For single-batch training, we use $T = 3 9 . 1 \times 1 0 ^ { 3 }$ steps. We run AdaScale and the LW baseline at $S = 1 6$ , and we compare the final validation accuracies.
+
+# C ROBUSTNESS TO AVERAGING PARAMETER
+
+In this appendix, we test the robustness of AdaScale to the averaging parameter $\theta$ for estimating gain ratios (see $\ S 3 . 3 )$ . When $\theta = 0$ , AdaScale does not average estimates of gradient moments. The closer $\theta$ is to 1, the more that AdaScale averages across iterations.
+
+Using the cifar10 benchmark, we compare four values of $\theta$ at scales $S = 8$ and $S = 3 2$ . The case $\theta = \mathbf { \bar { 1 } } - S / 1 0 0 0$ corresponds to the cifar10 experiment for Figure 1. We average the resulting metrics over five trials. Figure 6 contains the training curves.
+
+We also include final metric values in Table 4.
+
+For the three smaller settings of $\theta$ , the results align very closely. This suggests that AdaScale is robust to the choice of $\theta$ . When $\theta = 1 - S / 1 0 0 0 0$ , we see that smoothing more significantly biases gain ratio estimates, which leads to more contrasting results.
+
+# D ADDITIONAL EMPIRICAL RESULTS
+
+This appendix provides additional empirical results.
+
+![](images/f127cd0fe77ac96fb65e980bc16d555b436f3207175d9b1ac4602f396c25ed6a.jpg)  
+Figure 6: AdaScale training curves with varying moving average parameter.
+
+Table 4: AdaScale final metrics with varying moving average parameter.   
+
+<table><tr><td>S</td><td>0</td><td>Final val. accuracy (%)</td><td>Final train objective</td><td>Total iterations</td></tr><tr><td>8</td><td>1- S/10</td><td>94.0</td><td>0.153</td><td>5.75k</td></tr><tr><td></td><td>1- S/100</td><td>94.1</td><td>0.154</td><td>5.78k</td></tr><tr><td></td><td>1 - S/1000</td><td>94.1</td><td>0.153</td><td>5.85k</td></tr><tr><td></td><td>1 - S/10000</td><td>94.1</td><td>0.147</td><td>6.45k</td></tr><tr><td>32</td><td>0</td><td>94.0</td><td>0.145</td><td>2.02k</td></tr><tr><td></td><td>1- S/100</td><td>94.1</td><td>0.147</td><td>2.03k</td></tr><tr><td></td><td>1- S/1000</td><td>94.1</td><td>0.145</td><td>2.08k</td></tr><tr><td></td><td>1 - S/10000</td><td>94.1</td><td>0.136</td><td>2.46k</td></tr></table>
+
+# D.1 EFFECT OF NUMBER OF STEPS ON LINEAR SCALING WITH WARMUP
+
+As can be seen from empricial results in $\ S 4$ , AdaScale takes more steps than LSW for all scales. In order to understand the contribution of increased step number to the improved performance of AdaScale, we compare AdaScale to another algorithm called $\mathrm { L S W } +$ . $\mathrm { L S W } +$ runs for the same number of steps as AdaScale. It scales the steps axis of the LSW learning rate schedule while keeping the learning rate axis the same. Specifically, it takes single-batch schedule $1 \mathbf { r } _ { \mathrm { { S } 1 } } = \mathbf { \tau } _ { \mathrm { { T } } }$ and steps $T _ { S 1 } = T _ { A S }$ as inputs, where $T _ { A S }$ is the average number of iterations (over five trials) taken by AdaScale. It applys warm-up to the first $5 . 5 \%$ of the $T _ { A S }$ iterations. During warm-up, the learning rate increases linearly from $\mathtt { l r } _ { S 1 } ( 0 )$ to $S \cdot 1 \mathbf { r } _ { S 1 } ( 0 )$ .
+
+As can be seen from Table 5, the behavior of $\mathrm { L S W } +$ is generally similar to that of LSW. As expected, $\mathrm { L S W } +$ improves upon LSW, but $\mathrm { L S W } +$ still degrades model quality at larger scales for all problems. For speech, transformer, and yolo, $\mathrm { L S W } +$ diverges at the largest scales.
+
+We also note that $\mathrm { L S W } +$ is not a practical algorithm, because it requires either (i) first running AdaScale to determine the number of iterations; or (ii) tuning the number of iterations. The second path is inconvenient in practice. Moreover, it seems for a fair comparison, we would also need to consider AdaScale with tuning. Thus, even if $\mathrm { L S W } +$ matched AdaScale, which it does not, AdaScale would still be preferable to $\mathrm { L S W } +$ .
+
+![](images/df1d89721e8927afb3b4a8b3bfe8478de08281711c5113f4dd9f48b2144c0bbc.jpg)  
+Figure 7: Gain ratios for transformer. Plots compare moving average $r _ { t }$ estimates to values computed offline (using 1000 batches).
+
+# D.2 GAIN RATIO ESTIMATION
+
+Our online gain ratio estimates align closely with offline estimates (computed by averaging over 1000 batches). Figure 7 demonstrates this for the transformer task.
+
+# D.3 cifar10 SCALE INVARIANCE CURVES
+
+Figure 8 shows additional plots for the cifar10 task. Notably, training loss curves at various scales and full view of the learning rate curves are shown.
+
+Table 5: Comparison of AS and LSW+. Shorthand: AS=AdaScale, ${ \mathrm { L S W } } + { = } { \ l }$ Stretched linear scaling rule with warm-up, takes the same number of steps as AS gray $=$ model quality significantly worse than for $S = 1$ (5 trials, 0.95 significance), N/A=training diverges   
+
+<table><tr><td rowspan="2">Task</td><td rowspan="2">S</td><td rowspan="2">Total batch size</td><td colspan="2">Validation metric</td><td colspan="2">Training loss</td><td colspan="2">Total iterations</td></tr><tr><td>AS</td><td>LSW+</td><td>AS</td><td>LSW+</td><td>AS</td><td>LSW+</td></tr><tr><td>cifar10</td><td>1</td><td>128</td><td>94.1</td><td>94.1</td><td>0.157</td><td>0.157</td><td>39.1k</td><td>39.1k</td></tr><tr><td></td><td>8</td><td>1.02k</td><td>94.1</td><td>94.0</td><td>0.153</td><td>0.145</td><td>5.85k</td><td>5.85k</td></tr><tr><td></td><td>16</td><td>2.05k</td><td>94.1</td><td>94.1</td><td>0.150</td><td>0.136</td><td>3.36k</td><td>3.36k</td></tr><tr><td></td><td>32</td><td>4.10k</td><td>94.1</td><td>94.0</td><td>0.145</td><td>0.128</td><td>2.08k</td><td>2.08k</td></tr><tr><td></td><td>64</td><td>8.19k</td><td>93.9</td><td>93.0</td><td>0.140</td><td>0.128</td><td>1.41k</td><td>1.41k</td></tr><tr><td>imagenet</td><td>1</td><td>256</td><td>76.4</td><td>76.4</td><td>1.30</td><td>1.30</td><td>451k</td><td>451k</td></tr><tr><td></td><td>16</td><td>4.10k</td><td>76.5</td><td>76.5</td><td>1.26</td><td>1.27</td><td>33.2k</td><td>33.2k</td></tr><tr><td></td><td>32</td><td>8.19k</td><td>76.6</td><td>76.4</td><td>1.23</td><td>1.24</td><td>18.7k</td><td>18.7k</td></tr><tr><td></td><td>64</td><td>16.4k</td><td>76.5</td><td>76.5</td><td>1.19</td><td>1.20</td><td>11.2k</td><td>11.2k</td></tr><tr><td></td><td>128</td><td>32.8k</td><td>76.5</td><td>75.5</td><td>1.14</td><td>1.20</td><td>7.29k</td><td>7.29k</td></tr><tr><td>speech</td><td>1</td><td>32</td><td>79.6</td><td>79.6</td><td>2.03</td><td>2.03</td><td>84.8k</td><td>84.8k</td></tr><tr><td></td><td>4</td><td>128</td><td>81.0</td><td>81.0</td><td>5.21</td><td>4.22</td><td>22.5k</td><td>22.5k</td></tr><tr><td></td><td>8</td><td>256</td><td>80.7</td><td>80.7</td><td>6.74</td><td>6.61</td><td>12.1k</td><td>12.1k</td></tr><tr><td></td><td>16</td><td>512</td><td>80.6</td><td>N/A</td><td>7.33</td><td>N/A</td><td>6.95k</td><td>6.95k</td></tr><tr><td></td><td>32</td><td>1.02k</td><td>80.3</td><td>N/A</td><td>8.43</td><td>N/A</td><td>4.29k</td><td>4.29k</td></tr><tr><td>transformer</td><td>1</td><td>2.05k</td><td>27.2</td><td>27.2</td><td>1.60</td><td>1.60</td><td>1.55M</td><td>1.55M</td></tr><tr><td></td><td>16</td><td>32.8k</td><td>27.4</td><td>27.4</td><td>1.60</td><td>1.59</td><td>108k</td><td>108k</td></tr><tr><td></td><td>32</td><td>65.5k</td><td>27.3</td><td>27.3</td><td>1.59</td><td>1.59</td><td>58.9k</td><td>58.9k</td></tr><tr><td></td><td>64</td><td>131k</td><td>27.6</td><td>27.1</td><td>1.59</td><td>1.60</td><td>33.9k</td><td>33.9k</td></tr><tr><td></td><td>128</td><td>262k</td><td>27.4</td><td>N/A</td><td>1.59</td><td>N/A</td><td>21.4k</td><td>21.4k</td></tr><tr><td>yolo</td><td>1</td><td>16</td><td>80.2</td><td>80.2</td><td>2.65</td><td>2.65</td><td>207k</td><td>207k</td></tr><tr><td></td><td>16</td><td>256</td><td>81.5</td><td>81.9</td><td>2.63</td><td>2.47</td><td>15.9k</td><td>15.9k</td></tr><tr><td></td><td>32</td><td>512</td><td>81.3</td><td>81.7</td><td>2.61</td><td>2.42</td><td>9.27k</td><td>9.27k</td></tr><tr><td></td><td>64</td><td>1.02k</td><td>81.3</td><td>80.6</td><td>2.60</td><td>2.51</td><td>5.75k</td><td>5.75k</td></tr><tr><td></td><td>128</td><td>2.05k</td><td>81.4</td><td>N/A</td><td>2.57</td><td>N/A</td><td>4.07k</td><td>4.07k</td></tr></table>
+
+![](images/a549c8ff307cc5f0521067e64288c00330b9fb451d66854e6cfef35e32b1f5c3.jpg)  
+Figure 8: AdaScale training curves for cifar10. AdaScale trains quality models at various scales.
+
+![](images/3a00122015172c9452075666a9646990ca8f91048e84e90996f2231889ceb58d.jpg)  
+Figure 9: Learning rate adaptation for elastic AdaScaling. Gain ratio and learning rate curves for elastic scaling scenarios align with the corresponding curves for constant scaling scenarios, despite abrupt scale changes. (at $\tau _ { t } = 1 3 3 \mathbf { k }$ , $2 2 5 \mathrm { k }$ , dotted lines)
+
+# D.4 ELASTIC SCALING
+
+Learning rate and gain ratio curves for the two dynamic scaling scenarios we consider (discussed in $\ S 4 )$ align surprisingly well with the corresponding curves for the scenarios where the scale is kept constant throughout the training. This is shown in Figure 9. The abrupt change in scale causes the gain ratio to change quickly which in turn leads to an almost immediate change in learning rate. This allows the algorithm to quickly adapt to varying scales.