Add files using upload-large-folder tool

parse/train/B1eCk1StPH/B1eCk1StPH.md

@@ -0,0 +1,324 @@
+# THE GENERALIZATION-STABILITY TRADEOFF IN NEURAL NETWORK PRUNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Pruning neural network parameters is often viewed as a means to compress models, but pruning has also been motivated by the desire to prevent overfitting. This motivation is particularly relevant given the perhaps surprising observation that a wide variety of pruning approaches increase test accuracy despite sometimes massive reductions in parameter counts. To better understand this phenomenon, we analyze the behavior of pruning over the course of training, finding that pruning’s effect on generalization relies more on the instability it generates (defined as the drops in test accuracy immediately following pruning) than on the final size of the pruned model. We demonstrate that even the pruning of unimportant parameters can lead to such instability, and show similarities between pruning and regularizing by injecting noise, suggesting a mechanism for pruning-based generalization improvements that is compatible with the strong generalization recently observed in over-parameterized networks.
+
+# 1 INTRODUCTION
+
+Pruning weights and/or convolutional filters from deep neural networks (DNNs) can substantially shrink parameter counts with minimal loss in accuracy (LeCun et al., 1990; Hassibi & Stork, 1993; Han et al., 2015a; Li et al., 2016; Molchanov et al., 2017; Louizos et al., 2017; Liu et al., 2017; Ye et al., 2018), enabling broader application of DNNs via reductions in memory-footprint and inference-FLOPs requirements. Moreover, many pruning methods have been found to actually improve generalization (measured by model accuracy on previously unobserved inputs) (Narang et al., 2017; Frankle & Carbin, 2018; You et al., 2019). Consistent with this, pruning was originally motivated as a means to prevent over-parameterized networks from overfitting to comparatively small datasets (LeCun et al., 1990).
+
+Concern about over-parameterizing models has weakened, however, as many recent studies have found that adding parameters can actually reduce a DNN’s generalization-gap (the drop in performance when moving from previously seen to previously unseen inputs), even though it has been shown that the same networks have enough parameters to fit large datasets of randomized data (Neyshabur et al., 2014; Zhang et al., 2016). Potential explanations for this unintuitive phenomenon have come via experiments (Keskar et al., 2016; Morcos et al., 2018; Yao et al., 2018; Belkin et al., 2018; Nagarajan & Kolter, 2019), and the derivation of bounds on DNN generalization-gaps that suggest less overfitting might occur as parameter counts increase (Neyshabur et al., 2018). This research has implications for neural network pruning, where a puzzling question has arisen: if larger parameter counts don’t increase overfitting, how does pruning parameters throughout training improve generalization?
+
+To address this question we first introduce the notion of pruning instability, which we define to be the size of the drop in network accuracy caused by a pruning iteration (Section 3). We then empirically analyze the instability and generalization associated with various magnitude-pruning (Han et al., 2015b) algorithms in different settings, making the following contributions:
+
+1. We find a tradeoff between the stability and potential generalization benefits of pruning, and show iterative pruning’s similarity to regularizing with noise—suggesting a mechanism unrelated to parameter counts through which pruning appears to affect generalization. 2. We characterize the properties of pruning algorithms which lead to instability and correspondingly higher generalization.
+
+3. We derive a batch-normalized-parameter pruning algorithm to better control pruning stability.
+
+# 2 RELATED WORK
+
+There are various approaches to pruning neural networks. Pruning may be performed post-hoc (LeCun et al., 1990; Hassibi & Stork, 1993; Han et al., 2015b; Liu et al., 2017), or iteratively throughout training, such that there are multiple pruning events as the model trains (Hochreiter & Schmidhuber, 1997; Narang et al., 2017; Zhu & Gupta, 2017). Most methods prune parameters that appear unimportant to the function computed by the neural network, though means of identifying importance vary. Magnitude pruning (Han et al., 2015b) uses small-magnitude to indicate unimportance and has been shown to perform competitively with more sophisticated approaches (Gale et al., 2019).
+
+Many pruning studies have shown that the pruned model has heightened generalization (Narang et al., 2017; Frankle & Carbin, 2018; You et al., 2019), consistent with the fact that pruning may be framed as a regularization (rather than compression) approach. For example, variational Bayesian approaches to pruning via sparsity-inducing priors (Molchanov et al., 2017; Louizos et al., 2017) can describe weight removal as a process that reduces model description length, which in theory may help improve generalization (Rissanen, 1978). Similarly, the idea that models may be described more succinctly at flat minima has motivated pruning in service of flat minimum search (Hochreiter & Schmidhuber, 1997). Though Dinh et al. (2017) notes, however, that flatness can be arbitrarily modified by reparameterizing the function, and sharp minima can generalize well.
+
+VC dimension (a measure of model capacity) has motivated the use of iterative pruning to improve generalization (LeCun et al., 1990; Hassibi & Stork, 1993). Overfitting can be bounded above by an increasing function of VC dimension, which itself often increases with parameter counts, so fewer parameters can lead to a guarantee of less overfitting (Shalev-Shwartz & Ben-David, 2014). Unfortunately, such bounds can be so loose in practice that tightening them by reducing parameter counts need not translate to better generalization (Dziugaite & Roy, 2017).
+
+Rather than support parameter-count-based arguments for generalization in DNNs, our results suggest iterative DNN pruning may improve generalization by creating various noisy versions of the internal representation of the data, which unpruned parameters try to fit to, as in noise-injection regularization (Srivastava et al., 2014; Poole et al., 2014). Dropout creates particularly similar noise, as it temporarily sets random subsets of layer outputs to zero (likely changing an input’s internal representation every epoch). Indeed, applying dropout-like zeroing noise to a subset of features during training can encourage robustness to a post-hoc pruning of that subset (Leclerc et al., 2018; Gomez et al., 2018). Iterative DNN pruning noise ultimately differs, however, as it is: applied less frequently, not temporary (except in algorithms with weight re-entry), usually not random, and less well studied.
+
+# 3 APPROACH
+
+Given a neural network and set of test data, let $t$ be the top-1 test accuracy, the fraction of test data examples correctly classified multiplied by 100. We define a pruning algorithm’s instability on pruning iteration $i$ in terms of $t$ measured immediately before $( t _ { \mathrm { p r e } , i } )$ and immediately after $( { t _ { \mathrm { p o s t } } } , i )$ pruning: instability $\mathbf { \Phi } _ { i } = t _ { \mathrm { p r e } , i } - t _ { \mathrm { p o s t } , i }$ . In other words, the instability is the size of the accuracy drop caused by a particular pruning event.
+
+![](images/d90c35926ddb758855fbd88b7434acc191e754e2eb960dbdb71d79256df44966.jpg)
+
+This measure is related to a weight’s importance (sometimes referred to as “saliency”; LeCun et al. (1990); Hassibi & Stork (1993)) to the test accuracy, in that less stable pruning algorithms target more important sets of weights (all else equal). The stability of a pruning algorithm may be affected by many factors. Our experiments (Section 4) explore the effects of the following: pruning target, pruning schedule, iterative pruning rate, and model. The remainder of this section provides an overview of these factors and demonstrates a need for a novel pruning target, which we derive.
+
+# 3.1 PRUNING TARGET
+
+In all of our experiments, we use iterative magnitude pruning (Han et al., 2015b), which removes weights according to some magnitude-based rule, retrains the resulting smaller network to recover from the pruning, and repeats until the desired size reduction is met. We denote pruning algorithms that target the smallest-magnitude parameters with an "S" subscript (e.g. pruneS), random parameters with an "R" subscript, and the largest-magnitude parameters with an "L" subscript. The usual approach to pruning involves removing parameters that have the smallest magnitudes (Li et al., 2016; Gale et al., 2019), or, similarly, those parameters least important to the loss function as determined by some other metric (LeCun et al., 1990; Hassibi & Stork, 1993; Molchanov et al., 2016; 2017; Louizos et al., 2017; Ye et al., 2018; Yu et al., 2018; You et al., 2019).
+
+# 3.1.1 IDENTIFYING IMPORTANT BATCH-NORMALIZED PARAMETERS
+
+The correlation between parameter magnitude and importance weakens in the presence of batch normalization (BN) (Ioffe & Szegedy, 2015). Without batch normalization, a convolutional filter with weights $W$ will produce feature map activations with half the magnitude of a filter with weights $2 W$ : filter magnitude clearly scales the output. With batch normalization, however, the feature maps are normalized to have zero mean and unit variance, and their ultimate magnitudes depend on the BN affine-transformation parameters $\gamma$ and $\beta$ . As a result, in batch normalized networks, filter magnitude does not scale the output, and equating small magnitude and unimportance may therefore be particularly flawed. This has motivated approaches to use the scale parameter $\gamma$ ’s magnitude to find the convolutional filters that are important to the network’s output (Ye et al., 2018; You et al., 2019). Here, we derive a novel approach to determining filter importance/magnitude that incorporates both $\gamma$ and $\beta$ .
+
+To approximate the expected value/magnitude of a batch-normalized, post-ReLU feature map activation, we start by defining the 2D feature map produced by convolution with BN:
+
+$$
+M = \gamma \mathrm { B N } ( W * x ) + \beta .
+$$
+
+We approximate the activations within this feature map as $M _ { i j } \sim \mathcal { N } ( \beta , \gamma )$ . This approximation is justified if central limit theorem assumptions are met by the dot products in $W * x$ , and we empirically show in Figure A.1 that this approximation is highly accurate early in training, though it becomes less accurate as training progresses. Given this approximation, the post-ReLU feature map
+
+$$
+R = \operatorname* { m a x } \{ 0 , M \}
+$$
+
+has elements $R _ { i j }$ that are either 0 or samples from a truncated normal distribution with left truncation point $l = 0$ , right truncation point $r = \infty$ , and mean $\mu$ where
+
+$$
+\begin{array} { c } { \displaystyle { \mu = \gamma \frac { \phi ( \lambda ) - \phi ( \rho ) } { Z } + \beta , } } \\ { \displaystyle { \lambda = \frac { l - \beta } { \gamma } , \rho = \frac { r - \beta } { \gamma } , Z = \Phi ( \rho ) - \Phi ( \lambda ) , } } \end{array}
+$$
+
+and $\phi ( x )$ and $\Phi ( x )$ are the standard normal distribution’s PDF and CDF (respectively) evaluated at $x$ Thus, an approximation to the expected value of $R _ { i j }$ is given by
+
+$$
+\mathbb { E } [ R _ { i j } ] \approx \Phi ( \lambda ) 0 + ( 1 - \Phi ( \lambda ) ) \mu .
+$$
+
+We use the phrase "E[BN] pruning" to denote magnitude pruning that computes filter magnitude using this derived estimate of $\mathbb { E } [ R _ { i j } ]$ . E[BN] pruning has two advantages. First, this approach avoids the problematic assumption that filter importance is tied to filter $\ell _ { 2 }$ norm in a batch-normalized network. Accordingly, we hypothesize that E[BN] pruning can grant better control of the stability of the neural network’s output than pruning based on filters’ $\ell _ { 2 }$ norms. Second, the complexity of the calculation is negligible as it requires (per filter) just a handful of arithmetic operations on scalars, and two PDF and CDF evaluations, which makes it cheaper than a data-driven approach (e.g. approximating the expected value via the sample mean of feature map activations for a batch of feature maps).
+
+# 3.2 SUMMARY OF MODELS
+
+We consider three basic model classes: a simple network with convolutions (2x32, pool, 2x64, pool) and fully connected layers (512, 10) that we denote Conv4, VGG11 (Simonyan & Zisserman, 2014) with its fully-connected layers replaced by a single fully-connected layer, and ResNet18 (He et al., 2016). All convolutions are $3 \mathrm { x } 3$ . We trained these models using Adam (Kingma & Ba, 2014) with initial learning rate $l r = 0 . 0 0 1$ , as we found Adam more helpful than SGD for recovering from unstable pruning (seemingly consistent with the observation in Zhu & Gupta (2017) that recovery from pruning is more difficult when learning rates are low).
+
+# 3.3 ITERATIVE PRUNING RATE AND SCHEDULE
+
+For Conv4, we apply pruning to its first linear layer (which contains $94 \%$ of Conv4’s 1,250,858 parameters). For VGG/ResNet, pruning targets the final four convolutional layers (which contain $90 \%$ of VGG11’s 9,231,114 parameters, and $74 \%$ of ResNet18’s 11,173,962 parameters). Pruning focused on later layers partly because, as also found in Li et al. (2016); You et al. (2019), it allowed the network to recover more easily.
+
+The pruning algorithms we consider are iterative: we define a pruning schedule that describes the epochs on which pruning events occur, and set a corresponding (constant) iterative pruning rate that will ensure the total pruning percentage is met by the end of training (please see Appendix A.5 for rate and schedule details). Thus, throughout training, pruning steadily removes DNN parameters, with the iterative pruning rate determining the number pruned per event. While our plots label each pruning configuration with its iterative pruning rate, the total pruning percentages were: $42 \%$ of VGG11, $46 \%$ of ResNet18, and $10 \%$ of Conv4 (except in Appendix A.4, wherein we prune $8 5 \%$ of Conv4).
+
+# 4 EXPERIMENTS
+
+Pruning studies often aim to compress pre-trained models that generalize well, and consequently, much work has focused on metrics to identify parameter importance: if you can find the parameters that matter the least to the function computed by the DNN, then you can prune more parameters without significantly harming accuracy. As a bonus, such pruning methods can sometimes even increase generalization (Narang et al., 2017; Frankle & Carbin, 2018; You et al., 2019). However, the mechanism by which pruning induces higher generalization remains unclear. Here, rather than investigate how to best maintain accuracy when pruning the network, we instead focus on understanding the mechanisms underlying these generalization improvements.
+
+# 4.1 THE GENERALIZATION-STABILITY TRADEOFF
+
+Can improved generalization in pruned DNNs be explained by parameter-count reduction alone, or rather, do the properties of the pruning algorithm play an important role in generalization? As removing parameters from a DNN via pruning may make the DNN less capable of fitting to the noise in the training data, as originally suggested in LeCun et al. (1990); Hassibi & Stork (1993), we might expect that the generalization improvements observed in pruned DNNs are entirely explained by the number of parameters removed. In which case, methods that prune equal amounts of parameters would generalize similarly.
+
+Alternatively, perhaps some aspect of the pruning algorithm itself is responsible for increased generalization. This seems plausible as the reported generalization benefits of pruning vary widely across studies. One possible explanation for this variability is differences in the pruning algorithms themselves. A key differentiator of these algorithms is their stability: more stable approaches may compute a very close approximation to the way the loss changes with respect to each parameter and prune a single parameter at a time (Hassibi & Stork, 1993), while less stable approaches may assume that parameter magnitude and importance are roughly similar and prune many weights all at once (Han et al., 2015b). Therefore, to the extent that differences in pruning algorithms explain differences in pruning-based generalization improvements, we might expect to observe a relationship between generalization and pruning stability.
+
+![](images/19e2cdc46884dc3e8a0d28179f8e6de62523138be5f7951be6fa3ec66de1a015.jpg)  
+Figure 1: Pruning instability improves generalization of (Top) VGG11 and (Bottom) ResNet18 when training on CIFAR-10 (10 runs per configuration). (Left) Test accuracy during training of several models illustrates how adaptation to more unstable pruning leads to better generalization. (Right) Means reduce along the epoch dimension (creating one point per run-configuration combination).
+
+To determine whether pruning algorithm stability affects generalization, we compared the instability and final top-1 test accuracy of several pruning algorithms with varying pruning targets and iterative pruning rates (Figure 1). Consistent with the nature of the pruning algorithm playing a role in generalization, we observed that more unstable pruning algorithms created higher final test accuracies than those which were stable (Figure 1, right; VGG11: Pearson’s correlation $r \ = \ . 8 4$ , $\mathsf { p } \cdot$ -value $= 1 . 6 \mathrm { e } { - 1 1 }$ ; ResNet18: $r = . 6 5$ , $\mathsf { p }$ -value $= 5 \mathrm { { e - 5 } }$ ). While many pruning approaches have aimed to induce as little instability as possible, these results suggest that pruning techniques may actually facilitate better generalization when they induce more instability. Furthermore, these results suggest that parameter-count based arguments may not be sufficient to explain generalization in pruned DNNs, and suggest that the precise pruning method plays a critical role in this process.
+
+Figure 1 also demonstrates that pruning events for pruneL with a high iterative pruning rate (red curve, pruning as much as $13 \%$ of a given convolutional layer per pruning iteration) are substantially more destabilizing than other pruning events, but despite the dramatic pruning-induced drops in performance, the network recovers to higher performance within a few epochs. Several of these pruning events are highlighted with red arrows. Please see Appendix A.2 for visualization of the epoch-wise instabilities of each method in VGG11, and Appendix A.3 for an $\ell _ { 2 }$ -norm pruning version of Figure 1, which has qualitatively similar results.
+
+Interestingly, we initially observed that ResNet18 adapted to pruning events more quickly than VGG11 (accuracy rebounded after pruning then flattened soon after instead of climbing steadily). Thinking that shortcut connections were allowing the network to adapt to pruning events too easily, we tried pruning a larger amount of the penultimate block’s output layer: this reduced the number of shortcut connections to the final block’s output layer, lengthened the adaptation period, and improved generalization. This simple improvement of pruning hyperparameters suggests a potential for further optimization of the results shown. Please see Appendix A.5.1 for all hyperparameters/details of these experiments.
+
+# 4.2 THE ROLE OF WEIGHT MAGNITUDE IN PRUNING REGULARIZATION
+
+We have demonstrated that, perhaps surprisingly, pruning larger magnitude weights via the E[BN] algorithm can result in larger test accuracy improvements (Figure 1). This suggests a positive correlation between pruning target magnitude and pruning’s regularization effect. However, it’s not clear whether this relationship holds more generally; i.e., perhaps it was caused by a feature of our
+
+![](images/e00fd9be6e4a4818e1301731fda79db66fef95a0a2d0e7ba01e146713cb7b9e5.jpg)  
+Figure 2: When pruning $10 \%$ of Conv4’s largest dense layer, the final generalization gap depends on the magnitude of the weights that were pruned during training. This is particularly true when using unstructured pruning (left) rather than structured pruning (right).
+
+E[BN] algorithm or the networks examined. Alternatively, this effect may be dependent on whether nodes/filters (structured pruning) or individual parameters (unstructured pruning) are pruned.
+
+As such, we tested whether target weight magnitude correlates with pruning’s regularizing effect when using both unstructured and structured magnitude pruning on the penultimate linear layer of a small network without batch normalization (Conv4). Specifically, we constructed a pruning target for each weight-magnitude decile (see Appendix A.5.2 for details), used each target to prune ten separate networks as they trained, and compared the generalization gaps (test-train accuracy) of the pruned networks to the target pruned (Figure 2).
+
+For both unstructured and structured pruning (Figure 2 left and right, respectively), we found that pruning larger weights led to better generalization gaps, though, interestingly, this effect was much more dramatic in the context of unstructured pruning than structured pruning. One possible explanation for this is that, in structured pruning, the $\ell _ { 2 }$ norm of pruned neurons did not vary dramatically past the fifth decile, whereas the unstructured deciles were approximately distributed exponentially. As a result, the top $50 \%$ of filters for the structured case were not clearly distinguished, making magnitude pruning much more susceptible to small sources of noise. These results suggest that, when weight magnitudes vary considerably, pruning large magnitude weights may lead to improved generalization.
+
+Interestingly, for ResNet18, we actually found that structured pruneL (red line) performed better than unstructured pruneL (green line) (Figure 3). The worse performance of unstructured prune $\mathrm { L }$ may stem from its harming the helpful inductive bias provided by convolutional filters (i.e., perhaps removing the most important connections in all convolutional filters degrades performance more than pruning the same number of connections via removal of several entire filters) or its lower instability.
+
+![](images/f31953b032f27dea6a90c722d75e2f886ce59c1dd78256be00482474b9aab29a.jpg)  
+Figure 3: The top-1 test accuracy during training with multiple approaches to pruning ResNet18.
+
+# 4.3 THE ROLE OF ITERATIVE PRUNING RATE IN PRUNING INSTABILITY
+
+While pruning large magnitude weights appears to play a role in pruning’s ability to improve generalization, more commonly used pruning algorithms often see generalization improvements when targeting the smallest magnitude or least important parameters, suggesting that target magnitude/importance is not the only characteristic of pruning algorithms relevant to generalization. One possibility is that, given a pruning target, pruning more parameters per pruning iteration (while holding constant the total pruning percentage) may lead to greater instability. If this is the case, the generalization-stability tradeoff suggests that the increase in instability from raising the iterative pruning rate would coincide with improved generalization performance. Alternatively, if the pruning target or total pruning percentage is all that matters, we may expect that changing the iterative pruning rate (while keeping the pruning target and total pruning percentage fixed) would not affect generalization.
+
+![](images/e3e82db0d2e2e678569282dcea66aef91c4f814fef79b122ed025916cef45a6f.jpg)  
+Figure 4: In VGG11, increasing the iterative pruning rate (and decreasing the number of pruning events in order to hold total pruning percentage constant) leads to more instability, and can allow methods that target less important parameters to generalize better. Additionally, E[BN] magnitude better approximates parameter importance than $\ell _ { 2 }$ -norm magnitude (see Figure A2 for another example and discussion of this phenomenon). An unpruned baseline model has $8 5 . 2 1 \%$ accuracy.
+
+To test this, we plotted mean instability and test accuracy as a function of different iterative pruning rates for both $\ell _ { 2 }$ -norm and E[BN] pruning (Figure 4). Consistent with iterative pruning rate playing a role in instability, we find that (given a pruning target) more instability is induced by using larger iterative pruning rates (Figure 4 left). Moreover, pruning random or small magnitude parameters performs best at the largest iterative rate $( 3 0 \% )$ , supporting the idea that these methods require a source of instability to boost generalization. Note this suggests that, when targeting less important weights, higher iterative pruning rates during training can be an effective way to induce additional instability and generalization. (Algorithm and experiment details are available in Appendix A.5.4.)
+
+Perhaps strangely, higher iterative pruning rates did not translate to improved generalization when targeting the largest magnitude weights (pruneL) with $\ell _ { 2 }$ -norm pruning. The fact that pruneL does not generalize the best at the highest iterative pruning rate may be due to the reduction in pruning iterations required by the large iterative pruning rate (i.e., when the iterative rate is at $30 \%$ , the number of pruning events is capped at three, which removes $90 \%$ of a layer). Thus, while this rate grants more instability (Figure 4 left) per iteration, pruning affects the network less often. The idea that the regularizing effect of pruning is enhanced by pruning more often may also help explain the observation that methods that prune iteratively can generalize better (Han et al., 2015b).
+
+Another possibility is that, since raising the iterative pruning rate (and consequently the duration between pruning events) tends to make the $\ell _ { 2 }$ -norm worse for differentiating parameters by their importance to accuracy1, raising the iterative pruning rate causes pruneL with $\ell _ { 2 }$ -norm pruning to target less important weights. Consequently, prune $\mathrm { L }$ with $\ell _ { 2 }$ -norm pruning may generalize worse at higher iterative rates by leaving unpruned more important weights, the presence of which can harm model generalization (Hinton & Van Camp, 1993; Morcos et al., 2018). Relatedly, this also means that pruneS with $\ell _ { 2 }$ -norm pruning may increase (in networks with batch normalization at least) instability and generalization by failing to avoid the pruning of important parameters.
+
+# 4.4 ITERATIVE PRUNING AS NOISE INJECTION
+
+Our results thus far suggest that pruning improves generalization when it creates instability throughout training. These prior results, though, involved damaging model capacity simply by the nature of pruning, which decreases the number of model parameters. It therefore remains possible that the generalization benefits we’ve seen rely upon the reduction in capacity conferred by pruning. Here, we examine this critical question.
+
+We first note that iterative pruning can be viewed as noise injection (Srivastava et al., 2014; Poole et al., 2014), with the peculiarity that the noise permanently zeroes a subset of weights. Removing the permanence of this zeroing can mitigate some of the capacity effect of pruning2 and, therefore, help us isolate and study how iterative pruning regularizes through noise injection.
+
+![](images/8a31a7d0e45a9ee765b02718a1475e95dfa0f96d7d3ae657b61c0a1748b3fdb6.jpg)  
+Figure 5: Generalization improvements from pruning bear resemblance to those obtained by using temporary (Left) multiplicative zeroing noise, and (Right) additive Gaussian noise, as long as the noise is applied for enough batches/steps.
+
+As a baseline, we consider pruneL applied to VGG11, judging filter magnitude via the $\ell _ { 2 }$ -norm (additional experimental details are in Appendix A.5.5). We then modify this algorithm such that, rather than permanently prune filters, it simply multiplies the filter weights by zero, then allows the zeroed weights to immediately resume training in the network ("Zeroing $0 "$ in Figure 5 Left). However, by allowing pruned weights to immediately recover, this experiment also removes a key, potentially regularizing aspect of pruning noise: the requirement that the rest of the network adapts to fit the new representations generated by pruning. To encourage this potentially important facet of pruning noise, we also added variants that held weights to zero for 50 and 1500 consecutive batches3. As a related experiment, we also measured the impact of adding Gaussian noise to the weights in Figure 5, right. Noise was applied either once (Gaussian 0) or repeatedly over a series of training batches (Gaussian 50/1500).
+
+If the capacity effects of weight removal are not necessary to explain pruning’s effect on generalization, then we would expect that the generalization behavior of these non-permanent noise injection algorithms could mimic the generalization behavior of pruneL. Alternatively, if weight removal is a necessary component of pruning-based generalization improvements, then we would not expect close similarities between the generalization phenomena of pruneL and non-permanent pruning noise injection.
+
+Consistent with the capacity effects of weight removal not being necessary to explain generalization in pruned DNNs, applying zeroing noise for 50 batches to filters (rather than pruning them completely) generates strikingly similar accuracy to pruneL (Figure 5 Left). Specifically, the patterns in instability are qualitatively and quantitatively similar, as are the generalization levels throughout training.
+
+Importantly, we found that applying zeroing noise once (Zeroing 0; brown line) was not sufficient to generate better performance, suggesting that the regularization induced by forcing weights to adapt to noised representations is critical to pruning’s ability to improve generalization. Moreover, we found that, while applying Gaussian noise could increase generalization if applied for long enough (Gaussian 1500; purple line), it still did not match the performance of pruneL, suggesting that multiplicative zeroing noise is substantially more effective than additive Gaussian noise4. Together, these results demonstrate that pruning induced generalization benefits are not merely explained by weight removal, but rather are dependent on the regularization conferred by forcing networks to adapt to noised representations over a sufficiently long period throughout training.
+
+# 5 DISCUSSION
+
+In this study, we defined the notion of pruning algorithm instability, and applied several pruning approaches5 to multiple neural networks, assessing the approaches’ effects on instability and generalization. Throughout these experiments, we observed that pruning algorithms that generated more instability led to better generalization (as measured by test accuracy). For a given pruning target and total pruning percentage, instability and generalization could be fueled by raising iterative pruning rates (Figure 4, Section 4.3). Additionally, targeting more important weights, again holding total parameters pruned constant, led to more instability and generalization than targeting less important weights (Figure 1, Section 4.1).
+
+These results support the idea that the generalization benefits of pruning cannot be explained solely by pruning’s effect on parameter counts—the properties of the pruning algorithm must be taken into account. Our analysis also suggests that the capacity effects of weight-removal may not even be necessary to explain how pruning improves generalization. Indeed, we provide an interpretation of iterative pruning as noise injection, a popular approach to regularizing DNNs, and find that making pruning noise impermanent provides pruning-like generalization benefits while not removing as much capacity as permanent pruning (Figure 5, Section 4.4).
+
+# 5.1 CAVEATS AND FUTURE WORK
+
+While not emphasized in our discussion, pruning algorithm stability can be a desirable property, as recovery from pruning damage is not guaranteed. Indeed, pruning too many large/important weights can lead to worse final generalization (Li et al., 2016). Recovery appears to be a function of several factors, including: learning rate (Zhu & Gupta, 2017)); presence of an ongoing regularization effect (Figure 3, Section 4.2); preservation of helpful inductive biases (Figure 3, Section 4.2); and damage to network capacity (e.g., removing too much of an important layer could cause underfitting).
+
+A better understanding of the factors which aid recovery from pruning instability could aid the design of novel pruning algorithms. For example, pruning methods that allow weights to re-enter the network (Narang et al., 2017) could perhaps prune important weights occasionally to enhance generalization improvements, without risking permanent damage to the pruned networks (see Appendix A.4).
+
+In describing how pruning regularizes a model, we touched on similarities between pruning and noise injection. Our results, however, may also be consistent with other parameter-count-independent approaches to understanding generalization in neural networks, as pruning may reduce the information stored in the network’s weights (Hinton & Van Camp, 1993), and make the network more distributed (Morcos et al., 2018; Dettmers & Zettlemoyer, 2019). This raises the possibility that pruning noise engenders helpful properties in DNNs, though it remains unclear whether such properties might be identical to those achieved with more common noise injection schemes (Srivastava et al., 2014; Poole et al., 2014). Further exploration will be necessary to better understand the relationship between these approaches.
+
+One important caveat of our results is that they were generated with CIFAR-10, a relatively small dataset, so future work will be required to evaluate whether the presented phenomena hold in larger datasets. Relatedly, we only studied pruning’s regularizing effect in isolation and did not include commonly used regularizers (e.g., weight decay) in our setups. In future work, it would be interesting to examine whether pruning complements the generalization improvements of other commonly used regularization techniques.
+
+# REFERENCES
+
+Mikhail Belkin, Daniel Hsu, Siyuan Ma, and Soumik Mandal. Reconciling modern machine learning and the bias-variance trade-off. arXiv preprint arXiv:1812.11118, 2018.
+
+Tim Dettmers and Luke Zettlemoyer. Sparse networks from scratch: Faster training without losing performance. arXiv preprint arXiv:1907.04840, 2019.
+
+Laurent Dinh, Razvan Pascanu, Samy Bengio, and Yoshua Bengio. Sharp minima can generalize for deep nets. arXiv preprint arXiv:1703.04933, 2017.
+
+Gintare Karolina Dziugaite and Daniel M Roy. Computing nonvacuous generalization bounds for deep (stochastic) neural networks with many more parameters than training data. arXiv preprint arXiv:1703.11008, 2017.
+
+Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. arXiv preprint arXiv:1803.03635, 2018.
+
+Trevor Gale, Erich Elsen, and Sara Hooker. The state of sparsity in deep neural networks. CoRR, abs/1902.09574, 2019. URL http://arxiv.org/abs/1902.09574.
+
+Aidan N Gomez, Ivan Zhang, Kevin Swersky, Yarin Gal, and Geoffrey E Hinton. Targeted dropout. 2018.
+
+Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015a.
+
+Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In Advances in neural information processing systems, pp. 1135–1143, 2015b.
+
+Babak Hassibi and David G Stork. Second order derivatives for network pruning: Optimal brain surgeon. In Advances in neural information processing systems, pp. 164–171, 1993.
+
+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.
+
+Geoffrey E Hinton and Drew Van Camp. Keeping the neural networks simple by minimizing the description length of the weights. In Proceedings of the sixth annual conference on Computational learning theory, pp. 5–13. ACM, 1993.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Flat minima. Neural Computation, 9(1):1–42, 1997.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016.
+
+Diederik P 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. Technical report, Citeseer, 2009.
+
+Guillaume Leclerc, Manasi Vartak, Raul Castro Fernandez, Tim Kraska, and Samuel Madden. Smallify: Learning network size while training. arXiv preprint arXiv:1806.03723, 2018.
+
+Yann LeCun, John S Denker, and Sara A Solla. Optimal brain damage. In Advances in neural information processing systems, pp. 598–605, 1990.
+
+Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. arXiv preprint arXiv:1608.08710, 2016.
+
+Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In Computer Vision (ICCV), 2017 IEEE International Conference on, pp. 2755–2763. IEEE, 2017.
+
+Christos Louizos, Karen Ullrich, and Max Welling. Bayesian compression for deep learning. In Advances in Neural Information Processing Systems, pp. 3290–3300, 2017.
+
+Dmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. Variational dropout sparsifies deep neural networks. arXiv preprint arXiv:1701.05369, 2017.
+
+Pavlo Molchanov, Stephen Tyree, Tero Karras, Timo Aila, and Jan Kautz. Pruning convolutional neural networks for resource efficient transfer learning. arXiv preprint arXiv:1611.06440, 2016.
+
+Ari Morcos, David GT Barrett, Neil C Rabinowitz, and Matthew Botvinick. On the importance of single directions for generalization. In Proceeding of the International Conference on Learning Representations, 2018.
+
+Vaishnavh Nagarajan and J Zico Kolter. Generalization in deep networks: The role of distance from initialization. arXiv preprint arXiv:1901.01672, 2019.
+
+Sharan Narang, Gregory Diamos, Shubho Sengupta, and Erich Elsen. Exploring sparsity in recurrent neural networks. arXiv preprint arXiv:1704.05119, 2017.
+
+Behnam Neyshabur, Ryota Tomioka, and Nathan Srebro. In search of the real inductive bias: On the role of implicit regularization in deep learning. arXiv preprint arXiv:1412.6614, 2014.
+
+Behnam Neyshabur, Zhiyuan Li, Srinadh Bhojanapalli, Yann LeCun, and Nathan Srebro. Towards understanding the role of over-parametrization in generalization of neural networks. arXiv preprint arXiv:1805.12076, 2018.
+
+Ben Poole, Jascha Sohl-Dickstein, and Surya Ganguli. Analyzing noise in autoencoders and deep networks. arXiv preprint arXiv:1406.1831, 2014.
+
+Jorma Rissanen. Modeling by shortest data description. Automatica, 14(5):465–471, 1978.
+
+Shai Shalev-Shwartz and Shai Ben-David. Understanding machine learning: From theory to algorithms. Cambridge university press, 2014.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014.
+
+Zhewei Yao, Amir Gholami, Qi Lei, Kurt Keutzer, and Michael W Mahoney. Hessian-based analysis of large batch training and robustness to adversaries. In Advances in Neural Information Processing Systems, pp. 4949–4959, 2018.
+
+Jianbo Ye, Xin Lu, Zhe Lin, and James Z Wang. Rethinking the smaller-norm-less-informative assumption in channel pruning of convolution layers. arXiv preprint arXiv:1802.00124, 2018.
+
+Zhonghui You, Jinmian Yan, Kun; Ye, Meng Ma, and Ping Wang. Gate decorator: Global filter pruning method for accelerating deep convolutional neural networks. In Advances in Neural Information Processing Systems, 2019.
+
+Ruichi Yu, Ang Li, Chun-Fu Chen, Jui-Hsin Lai, Vlad I Morariu, Xintong Han, Mingfei Gao, Ching-Yung Lin, and Larry S Davis. Nisp: Pruning networks using neuron importance score propagation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9194–9203, 2018.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016.
+
+Michael Zhu and Suyog Gupta. To prune, or not to prune: exploring the efficacy of pruning for model compression. arXiv preprint arXiv:1710.01878, 2017.
+
+# A APPENDIX
+
+![](images/3b5e19e1693ec088e49d69b71323746c582fa9dffc86ae691f5f548228ce0e67.jpg)  
+Figure A1: We examined the normalized activations (shown in blue histograms) of feature maps in the final eight convolutional layers of VGG19 before (left) and after (right) training to convergence. We found that the approximation to standard normality (shown in orange) of these activations is reasonable early on but degrades with training (particularly in layers near the output).
+
+The main drawback to the E[BN] approach (Section 3.1.1) is the sometimes poor approximation $M _ { i j } \sim N ( \beta , \gamma )$ . In Figure A.1, the approximation’s quality depends on layer and training epoch. A less serious drawback is that this approach does not account for the strength of connections to the post-BN feature map, which could have activations with a large expected value but low importance if relatively small-magnitude weights connected the map to the following layer.
+
+![](images/33c01eafabc281b94017456ec830c848b3d07784a6a2164173bd46812fe2bac0.jpg)  
+Figure A2: In VGG11, pruneS E[BN] is more stable than pruneS, which uses filter- $\cdot \ell _ { 2 }$ -norm to compare parameter magnitudes. Methods with higher iterative pruning rates create more instability on a given iteration. Means reduce along the run dimension (10 runs per configuration).
+
+Note that this graph uses a method (pruneS) that was included in Figure 1 right, but was not displayed in Figure 1 left due to its similarity to pruneS E[BN]. Additional experimental details are in Section A.5.1.
+
+![](images/f7101c5956320628e4b182502af4a4ded6d93fb9d6d3371535b268180bcadae5.jpg)  
+Figure A3: Pruning instability improves generalization of (Top) VGG11 and (Bottom) ResNet18 when training on CIFAR-10 (10 runs per configuration). (Left) Test accuracy during training of several models illustrates how adaptation to more unstable pruning leads to better generalization. (Right) Means reduce along the epoch dimension (creating one point per run-configuration combination).
+
+Here we use the same training and pruning configurations that were used for Figure 1, but we replace E[BN] pruning with $\ell _ { 2 }$ -norm pruning. Qualitatively, the two figures’ results are similar. Interestingly, though, the correlation between instability and generalization is somewhat weaker with $\ell _ { 2 }$ -norm pruning. This may be explained by the fact that $\ell _ { 2 }$ -norm pruning generates a narrower spectrum of instabilities, which is perhaps due to $\ell _ { 2 }$ -norm scoring’s inability to accurately assess parameter importance (illustrated in Figure 4).
+
+![](images/4dd6577d3a5cc3026da504cca8754b9736abde758832547e9c90af72c14ebc6c.jpg)  
+Figure A4: When training Conv4 on CIFAR10, unstable pruning can significantly improve the baseline’s generalization. The training accuracies and test accuracies (the latter were calculated immediately after pruning) illustrate how much each pruning algorithm disturbs the neural network’s output during training.
+
+While it’s unclear how much unstable pruning, which is particularly damaging to capacity, can be sustained at high sparsity levels, prune $L$ can lead to generalization several percentage points above the baseline/prune $S$ when pruning $85 \%$ of Conv4. Please see Section A.5.6 for experimental setup details.
+
+# A.5 EXPERIMENTAL DETAILS
+
+Unstructured magnitude pruning entails removing individual weights (subsets of filters/neurons), which are selected for pruning based on their magnitude. Our unstructured pruning approach does not allow previously pruned weights to reenter the network (Narang et al., 2017; Zhu & Gupta, 2017; Gale et al., 2019). Structured magnitude pruning removes entire filters/neurons, which are selected based on their $\ell _ { 2 }$ -norms or via the E[BN] calculation. Except where noted, we use structured pruning for VGG11 and ResNet18.
+
+We denote the pruning of $n$ layers of a network by specifying a series of epochs at which pruning starts $s = ( s _ { 1 } , . . . , s _ { n } )$ , a series of epochs at which pruning ends $\boldsymbol { e } = ( e _ { 1 } , . . . , e _ { n } )$ , a series of fractions of parameters to remove $p = ( p _ { 1 } , . . . , p _ { n } )$ , and an inter-pruning-iteration retrain period $r \in \mathbb N$ . For a given layer $l$ , the retrain period $r$ and fraction $p _ { l }$ jointly determine the iterative pruning percentage $i _ { l }$ . Our experiments prune the same number of parameters $i _ { l } \times \mathrm { s i z e } ( l a y e r _ { l } )$ per pruning iteration, ultimately removing $p _ { l } \times 1 0 0 \%$ of the parameters by the end of epoch $e _ { l }$ .
+
+Our approach is designed to study the effects of changing factors such as the iterative pruning rate and lacks some practically helpful features, e.g. hyperparameters indicating how many parameters can be safely pruned (Liu et al., 2017; Molchanov et al., 2017). When layerwise iterative pruning percentages differ (i.e., when there exists an $a$ and $b$ such that $i _ { a }$ and $i _ { b }$ are unequal), our figures state the largest iterative pruning rate that was used in any of the layers.
+
+For ResNet, our pruning algorithms did not account for the magnitude of incoming shortcut connections when judging filter magnitude/importance. Though we did prune the incoming and outgoing shortcut connections associated with any pruned feature maps.
+
+We used only the CIFAR-10 dataset (Krizhevsky & Hinton, 2009) in our experiments, a limitation of our study. We used batch size 128, and only used data augmentation in the decile experiment (Figure 2). For some experiments, we give multi-step learning rate schedules $l r _ { s } = ( x , y )$ , which means we shrink the learning rate by a factor of 10 at epochs $x$ and $y$ .
+
+# A.5.1 FIGURE 1
+
+We used E[BN] pruning in all models that were pruned, except for one model that used $\ell _ { 2 }$ -norm magnitude pruning, which was included in Figure 1 right but not displayed in Figure 1 left due to its qualitative similarity to pruneS E[BN]. We leave out "E[BN]" in the legend of Figure 1 left, but all models nonetheless used E[BN] pruning.
+
+The models were trained on CIFAR-10 with Adam for 325 epochs with $l r _ { s } = ( 1 5 0 , 3 0 0 )$ . The error bars are $9 5 \%$ confidence intervals for the mean, bootstrapped from 10 distinct runs of each experiment.
+
+Since the layerwise pruning percentages varied, pruning required multiple iterative pruning percentages, the largest of which is denoted in the legend (rounded to the nearest integer).
+
+VGG11 Pruning targeted the final four convolutional layers during training with (layerwise) starting epochs $s = ( 3 , 4 , 5 , 6 )$ , ending epochs $e = ( 1 5 0 , 1 5 0 , 1 5 0 , 2 7 5 )$ , and pruning fractions $p = ( 0 . 3 , 0 . 3 , 0 . 3 , 0 . 9 )$ . To allow for the same amount of pruning among models with differing iterative pruning percentages, we adjusted the number of inter-pruning retraining epochs. The models with the maximum iterative pruning percentage of $1 \%$ had $r = 4$ , while the models with the maximum iterative pruning percentage of $13 \%$ had $r = 4 0$ . The model pruned with $\ell _ { 2 }$ -norm magnitude pruning, which only appeared in Figure 1 right, had $r = 4$ as well.
+
+ResNet18 Pruning targeted the final four convolutional layers of ResNet18 during training with (layerwise) starting epochs $s = ( 3 , 4 , 5 , 6 )$ , ending epochs $e = ( 1 5 0 , 1 5 0 , 1 7 0 , 2 7 5 )$ , and pruning fractions $p = ( 0 . 2 5 , 0 . 4 , 0 . 2 5 , 0 . 9 5 )$ . As noted in Section 4.1, we increased the pruning rate of the output layer of the penultimate block to remove shortcut connections to the last layer, thinking that it should increase the duration of adaptation to pruning. The models with the maximum iterative pruning percentage of $1 \%$ had $r = 4$ , while the models with the maximum iterative pruning percentage of $13 \%$ had $r = 4 0$ .
+
+# A.5.2 FIGURE 2
+
+Each experiment in Figure 2 targeted one of ten weight-magnitude deciles in the post-convolutional linear layer of the Conv4 network during training on CIFAR-10 with data augmentation.
+
+While there are just ten deciles, the iterative nature of our pruning algorithms required the creation of eleven different pruning targets: ten methods pruned from the bottom of the decile upward (one experiment for each decile’s starting point: 0th percentile, 10th percentile, etc.), and one (D10) pruned from the last decile’s ending point downward (pruning the very largest collection of weights each iteration). In other words, D9 and D10 targeted the same decile (90th percentile to maximum value), but only D10 actually removed the largest weights on a given iteration (weights in the 100th-99th percentiles, for example). The D9 experiment would target weights starting from the 90th percentile (e.g. it may prune the 90th-91st percentiles on a particular iteration).
+
+The training/pruning setup used the Adam optimizer, $s = ( 4 )$ , $e = ( 5 2 )$ , $p = ( 0 . 1 )$ , $r = 3$ , and $l r _ { s } = ( 3 0 , \bar { 6 } 0 )$ . We calculated the generalization gap on epoch 54 and sampled average pruned magnitudes on epoch 35. We obtained qualitatively similar results regardless of whether we used fewer training epochs or data augmentation. The error bars are $9 5 \%$ confidence intervals for the means, bootstrapped from 10 distinct runs of each configuration.
+
+# A.5.3 FIGURE 3
+
+In Figure 3, prune $\mathrm { L }$ was applied to the final four convolutional layers of ResNet18 during training with (layerwise) starting epochs $s = ( 3 , 4 , 5 , 6 )$ , ending epochs $e = ( 1 5 0 , 1 5 0 , 1 7 0 , 2 7 5 )$ , and pruning fractions $p = ( 0 . 2 5 , 0 . 4 , 0 . 2 5 , 0 . 9 5 )$ . Since the layerwise pruning percentages varied, pruning required multiple iterative pruning percentages, the largest of which is denoted in the legend (rounded to the nearest integer). The models with the maximum iterative pruning percentage of $1 \%$ had $r = 4$ , the models with the maximum iterative pruning percentage of $13 \%$ had $r = 4 0$ , and the "One Shot" model pruned all its targeted parameters at once on epoch 246.
+
+When performing unstructured pruning, we pruned individual weights from filters based on their magnitude. The structured pruning experiments used E[BN] pruning.
+
+The models were trained on CIFAR-10 with Adam for 325 epochs with $l r _ { s } = ( 1 5 0 , 3 0 0 )$ . The error bars are $9 5 \%$ confidence intervals for the means, bootstrapped from 10 distinct runs of each experiment.
+
+# A.5.4 FIGURE 4
+
+In Figure 4, pruning targeted the final four convolutional layers of VGG11 during training with (layerwise) starting epochs $s = ( 3 , 4 , 5 , 6 )$ , ending epochs $e = ( 1 5 0 , 1 5 0 , 1 5 0 , 2 7 5 )$ , and pruning fractions $p = ( 0 . 3 , 0 . 3 , 0 . 3 , 0 . 9 )$ . To create the different iterative pruning rates, we used models with inter-pruning retrain periods $r = 4$ , $r = 2 0$ , $r = 4 0$ , $r = 6 0$ , and $r = 1 0 0$ . Since the layerwise pruning percentages varied, pruning required multiple iterative pruning percentages, the largest of which is denoted on the horizontal axis. An unpruned baseline model average (10 runs) is plotted on the dotted line.
+
+The models were trained on CIFAR-10 with Adam for 325 epochs with $l r _ { s } = ( 1 5 0 , 3 0 0 )$ . The error bars are $9 5 \%$ confidence intervals for the means, bootstrapped from 10 distinct runs of each experiment.
+
+# A.5.5 FIGURE 5
+
+In Figure 5, pruning targeted the final four convolutional layers of VGG11 during training with (layerwise) starting epochs $s = ( 3 , 4 , 5 , 6 )$ , ending epochs $e = ( 1 5 0 , 1 5 0 , 1 5 0 , 2 7 5 )$ , pruning fractions $p = ( 0 . 3 , 0 . 3 , \bar { 0 } . 3 , 0 . 9 )$ , and inter-pruning-iteration retrain period $r = 4 0$ . When injecting pruning noise, we used the same pruning schedule and percentages, but applied noise to the parameters instead of removing them. The Gaussian noise had mean 0 and standard deviation equal to the empirical standard deviation of a noiseless filter from the same layer. Prune $\mathrm { L }$ used $\ell _ { 2 }$ -norm pruning.
+
+The models were trained on CIFAR-10 with Adam for 325 epochs with $l r _ { s } = ( 1 5 0 , 3 0 0 )$ . The error bars are $9 5 \%$ confidence intervals for the means, bootstrapped from 10 distinct runs of each experiment.
+
+# A.5.6 APPENDIX A.4
+
+Each experiment in Appendix A.4 targeted the post-convolutional linear layer of the Conv4 network during training on CIFAR-10 with the Adam optimizer. The pruning algorithms start on epoch $s = ( 3 )$ , end on epoch $e = ( 1 8 )$ , prune the percentage $p = ( 0 . 9 )$ , and prune every epoch via retrain period $r = 1$ . These relatively simple experiments were conducted to show that, at higher sparsity (pruning $85 \%$ of the model’s parameters), unstable pruning can improve the generalization of the baseline. The error bars are $9 5 \%$ confidence intervals for the means, bootstrapped from 20 distinct runs of each configuration.

parse/train/B1eCk1StPH/B1eCk1StPH_content_list.json

@@ -0,0 +1,1789 @@
+[
+    {
+        "type": "text",
+        "text": "THE GENERALIZATION-STABILITY TRADEOFF IN NEURAL NETWORK PRUNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            761,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pruning neural network parameters is often viewed as a means to compress models, but pruning has also been motivated by the desire to prevent overfitting. This motivation is particularly relevant given the perhaps surprising observation that a wide variety of pruning approaches increase test accuracy despite sometimes massive reductions in parameter counts. To better understand this phenomenon, we analyze the behavior of pruning over the course of training, finding that pruning’s effect on generalization relies more on the instability it generates (defined as the drops in test accuracy immediately following pruning) than on the final size of the pruned model. We demonstrate that even the pruning of unimportant parameters can lead to such instability, and show similarities between pruning and regularizing by injecting noise, suggesting a mechanism for pruning-based generalization improvements that is compatible with the strong generalization recently observed in over-parameterized networks. ",
+        "bbox": [
+            233,
+            265,
+            766,
+            445
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            472,
+            336,
+            487
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pruning weights and/or convolutional filters from deep neural networks (DNNs) can substantially shrink parameter counts with minimal loss in accuracy (LeCun et al., 1990; Hassibi & Stork, 1993; Han et al., 2015a; Li et al., 2016; Molchanov et al., 2017; Louizos et al., 2017; Liu et al., 2017; Ye et al., 2018), enabling broader application of DNNs via reductions in memory-footprint and inference-FLOPs requirements. Moreover, many pruning methods have been found to actually improve generalization (measured by model accuracy on previously unobserved inputs) (Narang et al., 2017; Frankle & Carbin, 2018; You et al., 2019). Consistent with this, pruning was originally motivated as a means to prevent over-parameterized networks from overfitting to comparatively small datasets (LeCun et al., 1990). ",
+        "bbox": [
+            174,
+            502,
+            825,
+            627
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Concern about over-parameterizing models has weakened, however, as many recent studies have found that adding parameters can actually reduce a DNN’s generalization-gap (the drop in performance when moving from previously seen to previously unseen inputs), even though it has been shown that the same networks have enough parameters to fit large datasets of randomized data (Neyshabur et al., 2014; Zhang et al., 2016). Potential explanations for this unintuitive phenomenon have come via experiments (Keskar et al., 2016; Morcos et al., 2018; Yao et al., 2018; Belkin et al., 2018; Nagarajan & Kolter, 2019), and the derivation of bounds on DNN generalization-gaps that suggest less overfitting might occur as parameter counts increase (Neyshabur et al., 2018). This research has implications for neural network pruning, where a puzzling question has arisen: if larger parameter counts don’t increase overfitting, how does pruning parameters throughout training improve generalization? ",
+        "bbox": [
+            174,
+            635,
+            825,
+            775
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To address this question we first introduce the notion of pruning instability, which we define to be the size of the drop in network accuracy caused by a pruning iteration (Section 3). We then empirically analyze the instability and generalization associated with various magnitude-pruning (Han et al., 2015b) algorithms in different settings, making the following contributions: ",
+        "bbox": [
+            176,
+            781,
+            825,
+            837
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1. We find a tradeoff between the stability and potential generalization benefits of pruning, and show iterative pruning’s similarity to regularizing with noise—suggesting a mechanism unrelated to parameter counts through which pruning appears to affect generalization. 2. We characterize the properties of pruning algorithms which lead to instability and correspondingly higher generalization. ",
+        "bbox": [
+            209,
+            848,
+            826,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "3. We derive a batch-normalized-parameter pruning algorithm to better control pruning stability. ",
+        "bbox": [
+            207,
+            103,
+            825,
+            118
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            137,
+            344,
+            154
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There are various approaches to pruning neural networks. Pruning may be performed post-hoc (LeCun et al., 1990; Hassibi & Stork, 1993; Han et al., 2015b; Liu et al., 2017), or iteratively throughout training, such that there are multiple pruning events as the model trains (Hochreiter & Schmidhuber, 1997; Narang et al., 2017; Zhu & Gupta, 2017). Most methods prune parameters that appear unimportant to the function computed by the neural network, though means of identifying importance vary. Magnitude pruning (Han et al., 2015b) uses small-magnitude to indicate unimportance and has been shown to perform competitively with more sophisticated approaches (Gale et al., 2019). ",
+        "bbox": [
+            174,
+            169,
+            825,
+            266
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Many pruning studies have shown that the pruned model has heightened generalization (Narang et al., 2017; Frankle & Carbin, 2018; You et al., 2019), consistent with the fact that pruning may be framed as a regularization (rather than compression) approach. For example, variational Bayesian approaches to pruning via sparsity-inducing priors (Molchanov et al., 2017; Louizos et al., 2017) can describe weight removal as a process that reduces model description length, which in theory may help improve generalization (Rissanen, 1978). Similarly, the idea that models may be described more succinctly at flat minima has motivated pruning in service of flat minimum search (Hochreiter & Schmidhuber, 1997). Though Dinh et al. (2017) notes, however, that flatness can be arbitrarily modified by reparameterizing the function, and sharp minima can generalize well. ",
+        "bbox": [
+            174,
+            272,
+            825,
+            398
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "VC dimension (a measure of model capacity) has motivated the use of iterative pruning to improve generalization (LeCun et al., 1990; Hassibi & Stork, 1993). Overfitting can be bounded above by an increasing function of VC dimension, which itself often increases with parameter counts, so fewer parameters can lead to a guarantee of less overfitting (Shalev-Shwartz & Ben-David, 2014). Unfortunately, such bounds can be so loose in practice that tightening them by reducing parameter counts need not translate to better generalization (Dziugaite & Roy, 2017). ",
+        "bbox": [
+            174,
+            405,
+            825,
+            489
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Rather than support parameter-count-based arguments for generalization in DNNs, our results suggest iterative DNN pruning may improve generalization by creating various noisy versions of the internal representation of the data, which unpruned parameters try to fit to, as in noise-injection regularization (Srivastava et al., 2014; Poole et al., 2014). Dropout creates particularly similar noise, as it temporarily sets random subsets of layer outputs to zero (likely changing an input’s internal representation every epoch). Indeed, applying dropout-like zeroing noise to a subset of features during training can encourage robustness to a post-hoc pruning of that subset (Leclerc et al., 2018; Gomez et al., 2018). Iterative DNN pruning noise ultimately differs, however, as it is: applied less frequently, not temporary (except in algorithms with weight re-entry), usually not random, and less well studied. ",
+        "bbox": [
+            174,
+            496,
+            825,
+            622
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 APPROACH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            641,
+            297,
+            656
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given a neural network and set of test data, let $t$ be the top-1 test accuracy, the fraction of test data examples correctly classified multiplied by 100. We define a pruning algorithm’s instability on pruning iteration $i$ in terms of $t$ measured immediately before $( t _ { \\mathrm { p r e } , i } )$ and immediately after $( { t _ { \\mathrm { p o s t } } } , i )$ pruning: instability $\\mathbf { \\Phi } _ { i } = t _ { \\mathrm { p r e } , i } - t _ { \\mathrm { p o s t } , i }$ . In other words, the instability is the size of the accuracy drop caused by a particular pruning event. ",
+        "bbox": [
+            174,
+            671,
+            825,
+            742
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/d90c35926ddb758855fbd88b7434acc191e754e2eb960dbdb71d79256df44966.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            757,
+            821,
+            823
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This measure is related to a weight’s importance (sometimes referred to as “saliency”; LeCun et al. (1990); Hassibi & Stork (1993)) to the test accuracy, in that less stable pruning algorithms target more important sets of weights (all else equal). The stability of a pruning algorithm may be affected by many factors. Our experiments (Section 4) explore the effects of the following: pruning target, pruning schedule, iterative pruning rate, and model. The remainder of this section provides an overview of these factors and demonstrates a need for a novel pruning target, which we derive. ",
+        "bbox": [
+            173,
+            840,
+            826,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 PRUNING TARGET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            339,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In all of our experiments, we use iterative magnitude pruning (Han et al., 2015b), which removes weights according to some magnitude-based rule, retrains the resulting smaller network to recover from the pruning, and repeats until the desired size reduction is met. We denote pruning algorithms that target the smallest-magnitude parameters with an \"S\" subscript (e.g. pruneS), random parameters with an \"R\" subscript, and the largest-magnitude parameters with an \"L\" subscript. The usual approach to pruning involves removing parameters that have the smallest magnitudes (Li et al., 2016; Gale et al., 2019), or, similarly, those parameters least important to the loss function as determined by some other metric (LeCun et al., 1990; Hassibi & Stork, 1993; Molchanov et al., 2016; 2017; Louizos et al., 2017; Ye et al., 2018; Yu et al., 2018; You et al., 2019). ",
+        "bbox": [
+            173,
+            131,
+            825,
+            256
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 IDENTIFYING IMPORTANT BATCH-NORMALIZED PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            275,
+            661,
+            290
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The correlation between parameter magnitude and importance weakens in the presence of batch normalization (BN) (Ioffe & Szegedy, 2015). Without batch normalization, a convolutional filter with weights $W$ will produce feature map activations with half the magnitude of a filter with weights $2 W$ : filter magnitude clearly scales the output. With batch normalization, however, the feature maps are normalized to have zero mean and unit variance, and their ultimate magnitudes depend on the BN affine-transformation parameters $\\gamma$ and $\\beta$ . As a result, in batch normalized networks, filter magnitude does not scale the output, and equating small magnitude and unimportance may therefore be particularly flawed. This has motivated approaches to use the scale parameter $\\gamma$ ’s magnitude to find the convolutional filters that are important to the network’s output (Ye et al., 2018; You et al., 2019). Here, we derive a novel approach to determining filter importance/magnitude that incorporates both $\\gamma$ and $\\beta$ . ",
+        "bbox": [
+            173,
+            301,
+            825,
+            454
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To approximate the expected value/magnitude of a batch-normalized, post-ReLU feature map activation, we start by defining the 2D feature map produced by convolution with BN: ",
+        "bbox": [
+            173,
+            460,
+            823,
+            489
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a67ad769d1461603ba3356e63c9fe64234391dbbb992eec55f51a996dad64e18.jpg",
+        "text": "$$\nM = \\gamma \\mathrm { B N } ( W * x ) + \\beta .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            500,
+            583,
+            517
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We approximate the activations within this feature map as $M _ { i j } \\sim \\mathcal { N } ( \\beta , \\gamma )$ . This approximation is justified if central limit theorem assumptions are met by the dot products in $W * x$ , and we empirically show in Figure A.1 that this approximation is highly accurate early in training, though it becomes less accurate as training progresses. Given this approximation, the post-ReLU feature map ",
+        "bbox": [
+            173,
+            531,
+            825,
+            588
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7e4539626a303489486bee342cea62e77288d2ea7392d72a94e7db8cd0a86a40.jpg",
+        "text": "$$\nR = \\operatorname* { m a x } \\{ 0 , M \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            598,
+            558,
+            616
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "has elements $R _ { i j }$ that are either 0 or samples from a truncated normal distribution with left truncation point $l = 0$ , right truncation point $r = \\infty$ , and mean $\\mu$ where ",
+        "bbox": [
+            173,
+            623,
+            825,
+            652
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ded052ea7a76174385539b375b9dca0eafd0d2cb0b70c8c43852c7dc39f3fbc8.jpg",
+        "text": "$$\n\\begin{array} { c } { \\displaystyle { \\mu = \\gamma \\frac { \\phi ( \\lambda ) - \\phi ( \\rho ) } { Z } + \\beta , } } \\\\ { \\displaystyle { \\lambda = \\frac { l - \\beta } { \\gamma } , \\rho = \\frac { r - \\beta } { \\gamma } , Z = \\Phi ( \\rho ) - \\Phi ( \\lambda ) , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            666,
+            642,
+            733
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and $\\phi ( x )$ and $\\Phi ( x )$ are the standard normal distribution’s PDF and CDF (respectively) evaluated at $x$ Thus, an approximation to the expected value of $R _ { i j }$ is given by ",
+        "bbox": [
+            169,
+            739,
+            825,
+            770
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3d393ff2143b1e50197e15db59af9f35b3421ea85ff412060f2975fbdd8cb8e3.jpg",
+        "text": "$$\n\\mathbb { E } [ R _ { i j } ] \\approx \\Phi ( \\lambda ) 0 + ( 1 - \\Phi ( \\lambda ) ) \\mu .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            779,
+            609,
+            797
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use the phrase \"E[BN] pruning\" to denote magnitude pruning that computes filter magnitude using this derived estimate of $\\mathbb { E } [ R _ { i j } ]$ . E[BN] pruning has two advantages. First, this approach avoids the problematic assumption that filter importance is tied to filter $\\ell _ { 2 }$ norm in a batch-normalized network. Accordingly, we hypothesize that E[BN] pruning can grant better control of the stability of the neural network’s output than pruning based on filters’ $\\ell _ { 2 }$ norms. Second, the complexity of the calculation is negligible as it requires (per filter) just a handful of arithmetic operations on scalars, and two PDF and CDF evaluations, which makes it cheaper than a data-driven approach (e.g. approximating the expected value via the sample mean of feature map activations for a batch of feature maps). ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 SUMMARY OF MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            377,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We consider three basic model classes: a simple network with convolutions (2x32, pool, 2x64, pool) and fully connected layers (512, 10) that we denote Conv4, VGG11 (Simonyan & Zisserman, 2014) with its fully-connected layers replaced by a single fully-connected layer, and ResNet18 (He et al., 2016). All convolutions are $3 \\mathrm { x } 3$ . We trained these models using Adam (Kingma & Ba, 2014) with initial learning rate $l r = 0 . 0 0 1$ , as we found Adam more helpful than SGD for recovering from unstable pruning (seemingly consistent with the observation in Zhu & Gupta (2017) that recovery from pruning is more difficult when learning rates are low). ",
+        "bbox": [
+            174,
+            131,
+            825,
+            228
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 ITERATIVE PRUNING RATE AND SCHEDULE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            248,
+            516,
+            262
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For Conv4, we apply pruning to its first linear layer (which contains $94 \\%$ of Conv4’s 1,250,858 parameters). For VGG/ResNet, pruning targets the final four convolutional layers (which contain $90 \\%$ of VGG11’s 9,231,114 parameters, and $74 \\%$ of ResNet18’s 11,173,962 parameters). Pruning focused on later layers partly because, as also found in Li et al. (2016); You et al. (2019), it allowed the network to recover more easily. ",
+        "bbox": [
+            174,
+            276,
+            825,
+            345
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The pruning algorithms we consider are iterative: we define a pruning schedule that describes the epochs on which pruning events occur, and set a corresponding (constant) iterative pruning rate that will ensure the total pruning percentage is met by the end of training (please see Appendix A.5 for rate and schedule details). Thus, throughout training, pruning steadily removes DNN parameters, with the iterative pruning rate determining the number pruned per event. While our plots label each pruning configuration with its iterative pruning rate, the total pruning percentages were: $42 \\%$ of VGG11, $46 \\%$ of ResNet18, and $10 \\%$ of Conv4 (except in Appendix A.4, wherein we prune $8 5 \\%$ of Conv4). ",
+        "bbox": [
+            174,
+            352,
+            825,
+            463
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            488,
+            326,
+            503
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Pruning studies often aim to compress pre-trained models that generalize well, and consequently, much work has focused on metrics to identify parameter importance: if you can find the parameters that matter the least to the function computed by the DNN, then you can prune more parameters without significantly harming accuracy. As a bonus, such pruning methods can sometimes even increase generalization (Narang et al., 2017; Frankle & Carbin, 2018; You et al., 2019). However, the mechanism by which pruning induces higher generalization remains unclear. Here, rather than investigate how to best maintain accuracy when pruning the network, we instead focus on understanding the mechanisms underlying these generalization improvements. ",
+        "bbox": [
+            174,
+            521,
+            825,
+            632
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 THE GENERALIZATION-STABILITY TRADEOFF ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            652,
+            534,
+            667
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Can improved generalization in pruned DNNs be explained by parameter-count reduction alone, or rather, do the properties of the pruning algorithm play an important role in generalization? As removing parameters from a DNN via pruning may make the DNN less capable of fitting to the noise in the training data, as originally suggested in LeCun et al. (1990); Hassibi & Stork (1993), we might expect that the generalization improvements observed in pruned DNNs are entirely explained by the number of parameters removed. In which case, methods that prune equal amounts of parameters would generalize similarly. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            777
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Alternatively, perhaps some aspect of the pruning algorithm itself is responsible for increased generalization. This seems plausible as the reported generalization benefits of pruning vary widely across studies. One possible explanation for this variability is differences in the pruning algorithms themselves. A key differentiator of these algorithms is their stability: more stable approaches may compute a very close approximation to the way the loss changes with respect to each parameter and prune a single parameter at a time (Hassibi & Stork, 1993), while less stable approaches may assume that parameter magnitude and importance are roughly similar and prune many weights all at once (Han et al., 2015b). Therefore, to the extent that differences in pruning algorithms explain differences in pruning-based generalization improvements, we might expect to observe a relationship between generalization and pruning stability. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/19e2cdc46884dc3e8a0d28179f8e6de62523138be5f7951be6fa3ec66de1a015.jpg",
+        "image_caption": [
+            "Figure 1: Pruning instability improves generalization of (Top) VGG11 and (Bottom) ResNet18 when training on CIFAR-10 (10 runs per configuration). (Left) Test accuracy during training of several models illustrates how adaptation to more unstable pruning leads to better generalization. (Right) Means reduce along the epoch dimension (creating one point per run-configuration combination). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            106,
+            818,
+            358
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To determine whether pruning algorithm stability affects generalization, we compared the instability and final top-1 test accuracy of several pruning algorithms with varying pruning targets and iterative pruning rates (Figure 1). Consistent with the nature of the pruning algorithm playing a role in generalization, we observed that more unstable pruning algorithms created higher final test accuracies than those which were stable (Figure 1, right; VGG11: Pearson’s correlation $r \\ = \\ . 8 4$ , $\\mathsf { p } \\cdot$ -value $= 1 . 6 \\mathrm { e } { - 1 1 }$ ; ResNet18: $r = . 6 5$ , $\\mathsf { p }$ -value $= 5 \\mathrm { { e - 5 } }$ ). While many pruning approaches have aimed to induce as little instability as possible, these results suggest that pruning techniques may actually facilitate better generalization when they induce more instability. Furthermore, these results suggest that parameter-count based arguments may not be sufficient to explain generalization in pruned DNNs, and suggest that the precise pruning method plays a critical role in this process. ",
+        "bbox": [
+            173,
+            459,
+            825,
+            598
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 also demonstrates that pruning events for pruneL with a high iterative pruning rate (red curve, pruning as much as $13 \\%$ of a given convolutional layer per pruning iteration) are substantially more destabilizing than other pruning events, but despite the dramatic pruning-induced drops in performance, the network recovers to higher performance within a few epochs. Several of these pruning events are highlighted with red arrows. Please see Appendix A.2 for visualization of the epoch-wise instabilities of each method in VGG11, and Appendix A.3 for an $\\ell _ { 2 }$ -norm pruning version of Figure 1, which has qualitatively similar results. ",
+        "bbox": [
+            173,
+            604,
+            825,
+            702
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, we initially observed that ResNet18 adapted to pruning events more quickly than VGG11 (accuracy rebounded after pruning then flattened soon after instead of climbing steadily). Thinking that shortcut connections were allowing the network to adapt to pruning events too easily, we tried pruning a larger amount of the penultimate block’s output layer: this reduced the number of shortcut connections to the final block’s output layer, lengthened the adaptation period, and improved generalization. This simple improvement of pruning hyperparameters suggests a potential for further optimization of the results shown. Please see Appendix A.5.1 for all hyperparameters/details of these experiments. ",
+        "bbox": [
+            174,
+            709,
+            825,
+            820
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 THE ROLE OF WEIGHT MAGNITUDE IN PRUNING REGULARIZATION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            840,
+            684,
+            854
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We have demonstrated that, perhaps surprisingly, pruning larger magnitude weights via the E[BN] algorithm can result in larger test accuracy improvements (Figure 1). This suggests a positive correlation between pruning target magnitude and pruning’s regularization effect. However, it’s not clear whether this relationship holds more generally; i.e., perhaps it was caused by a feature of our ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/e00fd9be6e4a4818e1301731fda79db66fef95a0a2d0e7ba01e146713cb7b9e5.jpg",
+        "image_caption": [
+            "Figure 2: When pruning $10 \\%$ of Conv4’s largest dense layer, the final generalization gap depends on the magnitude of the weights that were pruned during training. This is particularly true when using unstructured pruning (left) rather than structured pruning (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            103,
+            816,
+            250
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "E[BN] algorithm or the networks examined. Alternatively, this effect may be dependent on whether nodes/filters (structured pruning) or individual parameters (unstructured pruning) are pruned. ",
+        "bbox": [
+            174,
+            337,
+            823,
+            366
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As such, we tested whether target weight magnitude correlates with pruning’s regularizing effect when using both unstructured and structured magnitude pruning on the penultimate linear layer of a small network without batch normalization (Conv4). Specifically, we constructed a pruning target for each weight-magnitude decile (see Appendix A.5.2 for details), used each target to prune ten separate networks as they trained, and compared the generalization gaps (test-train accuracy) of the pruned networks to the target pruned (Figure 2). ",
+        "bbox": [
+            174,
+            372,
+            825,
+            455
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For both unstructured and structured pruning (Figure 2 left and right, respectively), we found that pruning larger weights led to better generalization gaps, though, interestingly, this effect was much more dramatic in the context of unstructured pruning than structured pruning. One possible explanation for this is that, in structured pruning, the $\\ell _ { 2 }$ norm of pruned neurons did not vary dramatically past the fifth decile, whereas the unstructured deciles were approximately distributed exponentially. As a result, the top $50 \\%$ of filters for the structured case were not clearly distinguished, making magnitude pruning much more susceptible to small sources of noise. These results suggest that, when weight magnitudes vary considerably, pruning large magnitude weights may lead to improved generalization. ",
+        "bbox": [
+            173,
+            462,
+            825,
+            588
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, for ResNet18, we actually found that structured pruneL (red line) performed better than unstructured pruneL (green line) (Figure 3). The worse performance of unstructured prune $\\mathrm { L }$ may stem from its harming the helpful inductive bias provided by convolutional filters (i.e., perhaps removing the most important connections in all convolutional filters degrades performance more than pruning the same number of connections via removal of several entire filters) or its lower instability. ",
+        "bbox": [
+            174,
+            594,
+            472,
+            747
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/f31953b032f27dea6a90c722d75e2f886ce59c1dd78256be00482474b9aab29a.jpg",
+        "image_caption": [
+            "Figure 3: The top-1 test accuracy during training with multiple approaches to pruning ResNet18. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            486,
+            597,
+            823,
+            702
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 THE ROLE OF ITERATIVE PRUNING RATE IN PRUNING INSTABILITY",
+        "text_level": 1,
+        "bbox": [
+            174,
+            770,
+            681,
+            785
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While pruning large magnitude weights appears to play a role in pruning’s ability to improve generalization, more commonly used pruning algorithms often see generalization improvements when targeting the smallest magnitude or least important parameters, suggesting that target magnitude/importance is not the only characteristic of pruning algorithms relevant to generalization. One possibility is that, given a pruning target, pruning more parameters per pruning iteration (while holding constant the total pruning percentage) may lead to greater instability. If this is the case, the generalization-stability tradeoff suggests that the increase in instability from raising the iterative pruning rate would coincide with improved generalization performance. Alternatively, if the pruning target or total pruning percentage is all that matters, we may expect that changing the iterative pruning rate (while keeping the pruning target and total pruning percentage fixed) would not affect generalization. ",
+        "bbox": [
+            173,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/e3e82db0d2e2e678569282dcea66aef91c4f814fef79b122ed025916cef45a6f.jpg",
+        "image_caption": [
+            "Figure 4: In VGG11, increasing the iterative pruning rate (and decreasing the number of pruning events in order to hold total pruning percentage constant) leads to more instability, and can allow methods that target less important parameters to generalize better. Additionally, E[BN] magnitude better approximates parameter importance than $\\ell _ { 2 }$ -norm magnitude (see Figure A2 for another example and discussion of this phenomenon). An unpruned baseline model has $8 5 . 2 1 \\%$ accuracy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            99,
+            820,
+            220
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            334,
+            821,
+            362
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To test this, we plotted mean instability and test accuracy as a function of different iterative pruning rates for both $\\ell _ { 2 }$ -norm and E[BN] pruning (Figure 4). Consistent with iterative pruning rate playing a role in instability, we find that (given a pruning target) more instability is induced by using larger iterative pruning rates (Figure 4 left). Moreover, pruning random or small magnitude parameters performs best at the largest iterative rate $( 3 0 \\% )$ , supporting the idea that these methods require a source of instability to boost generalization. Note this suggests that, when targeting less important weights, higher iterative pruning rates during training can be an effective way to induce additional instability and generalization. (Algorithm and experiment details are available in Appendix A.5.4.) ",
+        "bbox": [
+            174,
+            369,
+            825,
+            481
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Perhaps strangely, higher iterative pruning rates did not translate to improved generalization when targeting the largest magnitude weights (pruneL) with $\\ell _ { 2 }$ -norm pruning. The fact that pruneL does not generalize the best at the highest iterative pruning rate may be due to the reduction in pruning iterations required by the large iterative pruning rate (i.e., when the iterative rate is at $30 \\%$ , the number of pruning events is capped at three, which removes $90 \\%$ of a layer). Thus, while this rate grants more instability (Figure 4 left) per iteration, pruning affects the network less often. The idea that the regularizing effect of pruning is enhanced by pruning more often may also help explain the observation that methods that prune iteratively can generalize better (Han et al., 2015b). ",
+        "bbox": [
+            174,
+            488,
+            825,
+            599
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Another possibility is that, since raising the iterative pruning rate (and consequently the duration between pruning events) tends to make the $\\ell _ { 2 }$ -norm worse for differentiating parameters by their importance to accuracy1, raising the iterative pruning rate causes pruneL with $\\ell _ { 2 }$ -norm pruning to target less important weights. Consequently, prune $\\mathrm { L }$ with $\\ell _ { 2 }$ -norm pruning may generalize worse at higher iterative rates by leaving unpruned more important weights, the presence of which can harm model generalization (Hinton & Van Camp, 1993; Morcos et al., 2018). Relatedly, this also means that pruneS with $\\ell _ { 2 }$ -norm pruning may increase (in networks with batch normalization at least) instability and generalization by failing to avoid the pruning of important parameters. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            717
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 ITERATIVE PRUNING AS NOISE INJECTION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            741,
+            508,
+            756
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our results thus far suggest that pruning improves generalization when it creates instability throughout training. These prior results, though, involved damaging model capacity simply by the nature of pruning, which decreases the number of model parameters. It therefore remains possible that the generalization benefits we’ve seen rely upon the reduction in capacity conferred by pruning. Here, we examine this critical question. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            840
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We first note that iterative pruning can be viewed as noise injection (Srivastava et al., 2014; Poole et al., 2014), with the peculiarity that the noise permanently zeroes a subset of weights. Removing the permanence of this zeroing can mitigate some of the capacity effect of pruning2 and, therefore, help us isolate and study how iterative pruning regularizes through noise injection. ",
+        "bbox": [
+            176,
+            847,
+            823,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/8a31a7d0e45a9ee765b02718a1475e95dfa0f96d7d3ae657b61c0a1748b3fdb6.jpg",
+        "image_caption": [
+            "Figure 5: Generalization improvements from pruning bear resemblance to those obtained by using temporary (Left) multiplicative zeroing noise, and (Right) additive Gaussian noise, as long as the noise is applied for enough batches/steps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            104,
+            813,
+            266
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            348,
+            823,
+            377
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As a baseline, we consider pruneL applied to VGG11, judging filter magnitude via the $\\ell _ { 2 }$ -norm (additional experimental details are in Appendix A.5.5). We then modify this algorithm such that, rather than permanently prune filters, it simply multiplies the filter weights by zero, then allows the zeroed weights to immediately resume training in the network (\"Zeroing $0 \"$ in Figure 5 Left). However, by allowing pruned weights to immediately recover, this experiment also removes a key, potentially regularizing aspect of pruning noise: the requirement that the rest of the network adapts to fit the new representations generated by pruning. To encourage this potentially important facet of pruning noise, we also added variants that held weights to zero for 50 and 1500 consecutive batches3. As a related experiment, we also measured the impact of adding Gaussian noise to the weights in Figure 5, right. Noise was applied either once (Gaussian 0) or repeatedly over a series of training batches (Gaussian 50/1500). ",
+        "bbox": [
+            173,
+            383,
+            825,
+            536
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "If the capacity effects of weight removal are not necessary to explain pruning’s effect on generalization, then we would expect that the generalization behavior of these non-permanent noise injection algorithms could mimic the generalization behavior of pruneL. Alternatively, if weight removal is a necessary component of pruning-based generalization improvements, then we would not expect close similarities between the generalization phenomena of pruneL and non-permanent pruning noise injection. ",
+        "bbox": [
+            173,
+            544,
+            825,
+            626
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Consistent with the capacity effects of weight removal not being necessary to explain generalization in pruned DNNs, applying zeroing noise for 50 batches to filters (rather than pruning them completely) generates strikingly similar accuracy to pruneL (Figure 5 Left). Specifically, the patterns in instability are qualitatively and quantitatively similar, as are the generalization levels throughout training. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            690
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Importantly, we found that applying zeroing noise once (Zeroing 0; brown line) was not sufficient to generate better performance, suggesting that the regularization induced by forcing weights to adapt to noised representations is critical to pruning’s ability to improve generalization. Moreover, we found that, while applying Gaussian noise could increase generalization if applied for long enough (Gaussian 1500; purple line), it still did not match the performance of pruneL, suggesting that multiplicative zeroing noise is substantially more effective than additive Gaussian noise4. Together, these results demonstrate that pruning induced generalization benefits are not merely explained by weight removal, but rather are dependent on the regularization conferred by forcing networks to adapt to noised representations over a sufficiently long period throughout training. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            821
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            310,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this study, we defined the notion of pruning algorithm instability, and applied several pruning approaches5 to multiple neural networks, assessing the approaches’ effects on instability and generalization. Throughout these experiments, we observed that pruning algorithms that generated more instability led to better generalization (as measured by test accuracy). For a given pruning target and total pruning percentage, instability and generalization could be fueled by raising iterative pruning rates (Figure 4, Section 4.3). Additionally, targeting more important weights, again holding total parameters pruned constant, led to more instability and generalization than targeting less important weights (Figure 1, Section 4.1). ",
+        "bbox": [
+            174,
+            135,
+            825,
+            246
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "These results support the idea that the generalization benefits of pruning cannot be explained solely by pruning’s effect on parameter counts—the properties of the pruning algorithm must be taken into account. Our analysis also suggests that the capacity effects of weight-removal may not even be necessary to explain how pruning improves generalization. Indeed, we provide an interpretation of iterative pruning as noise injection, a popular approach to regularizing DNNs, and find that making pruning noise impermanent provides pruning-like generalization benefits while not removing as much capacity as permanent pruning (Figure 5, Section 4.4). ",
+        "bbox": [
+            174,
+            253,
+            825,
+            351
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.1 CAVEATS AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            369,
+            424,
+            383
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While not emphasized in our discussion, pruning algorithm stability can be a desirable property, as recovery from pruning damage is not guaranteed. Indeed, pruning too many large/important weights can lead to worse final generalization (Li et al., 2016). Recovery appears to be a function of several factors, including: learning rate (Zhu & Gupta, 2017)); presence of an ongoing regularization effect (Figure 3, Section 4.2); preservation of helpful inductive biases (Figure 3, Section 4.2); and damage to network capacity (e.g., removing too much of an important layer could cause underfitting). ",
+        "bbox": [
+            174,
+            396,
+            825,
+            481
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A better understanding of the factors which aid recovery from pruning instability could aid the design of novel pruning algorithms. For example, pruning methods that allow weights to re-enter the network (Narang et al., 2017) could perhaps prune important weights occasionally to enhance generalization improvements, without risking permanent damage to the pruned networks (see Appendix A.4). ",
+        "bbox": [
+            176,
+            487,
+            825,
+            542
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In describing how pruning regularizes a model, we touched on similarities between pruning and noise injection. Our results, however, may also be consistent with other parameter-count-independent approaches to understanding generalization in neural networks, as pruning may reduce the information stored in the network’s weights (Hinton & Van Camp, 1993), and make the network more distributed (Morcos et al., 2018; Dettmers & Zettlemoyer, 2019). This raises the possibility that pruning noise engenders helpful properties in DNNs, though it remains unclear whether such properties might be identical to those achieved with more common noise injection schemes (Srivastava et al., 2014; Poole et al., 2014). Further exploration will be necessary to better understand the relationship between these approaches. ",
+        "bbox": [
+            174,
+            549,
+            825,
+            675
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "One important caveat of our results is that they were generated with CIFAR-10, a relatively small dataset, so future work will be required to evaluate whether the presented phenomena hold in larger datasets. Relatedly, we only studied pruning’s regularizing effect in isolation and did not include commonly used regularizers (e.g., weight decay) in our setups. In future work, it would be interesting to examine whether pruning complements the generalization improvements of other commonly used regularization techniques. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            766
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            789,
+            285,
+            804
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mikhail Belkin, Daniel Hsu, Siyuan Ma, and Soumik Mandal. Reconciling modern machine learning and the bias-variance trade-off. arXiv preprint arXiv:1812.11118, 2018. ",
+        "bbox": [
+            176,
+            814,
+            823,
+            842
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tim Dettmers and Luke Zettlemoyer. Sparse networks from scratch: Faster training without losing performance. arXiv preprint arXiv:1907.04840, 2019. ",
+        "bbox": [
+            176,
+            854,
+            823,
+            883
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, Razvan Pascanu, Samy Bengio, and Yoshua Bengio. Sharp minima can generalize for deep nets. arXiv preprint arXiv:1703.04933, 2017. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gintare Karolina Dziugaite and Daniel M Roy. Computing nonvacuous generalization bounds for deep (stochastic) neural networks with many more parameters than training data. arXiv preprint arXiv:1703.11008, 2017. ",
+        "bbox": [
+            174,
+            141,
+            823,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. arXiv preprint arXiv:1803.03635, 2018. ",
+        "bbox": [
+            169,
+            193,
+            825,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Trevor Gale, Erich Elsen, and Sara Hooker. The state of sparsity in deep neural networks. CoRR, abs/1902.09574, 2019. URL http://arxiv.org/abs/1902.09574. ",
+        "bbox": [
+            174,
+            231,
+            825,
+            261
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aidan N Gomez, Ivan Zhang, Kevin Swersky, Yarin Gal, and Geoffrey E Hinton. Targeted dropout. 2018. ",
+        "bbox": [
+            174,
+            268,
+            823,
+            297
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015a. ",
+        "bbox": [
+            174,
+            306,
+            823,
+            337
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In Advances in neural information processing systems, pp. 1135–1143, 2015b. ",
+        "bbox": [
+            173,
+            344,
+            826,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Babak Hassibi and David G Stork. Second order derivatives for network pruning: Optimal brain surgeon. In Advances in neural information processing systems, pp. 164–171, 1993. ",
+        "bbox": [
+            174,
+            397,
+            823,
+            426
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            434,
+            825,
+            478
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton and Drew Van Camp. Keeping the neural networks simple by minimizing the description length of the weights. In Proceedings of the sixth annual conference on Computational learning theory, pp. 5–13. ACM, 1993. ",
+        "bbox": [
+            174,
+            486,
+            823,
+            530
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jürgen Schmidhuber. Flat minima. Neural Computation, 9(1):1–42, 1997. ",
+        "bbox": [
+            174,
+            539,
+            797,
+            555
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015. ",
+        "bbox": [
+            171,
+            563,
+            823,
+            593
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016. ",
+        "bbox": [
+            178,
+            601,
+            823,
+            643
+        ],
+        "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": [
+            171,
+            652,
+            823,
+            683
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009. ",
+        "bbox": [
+            171,
+            690,
+            825,
+            720
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Leclerc, Manasi Vartak, Raul Castro Fernandez, Tim Kraska, and Samuel Madden. Smallify: Learning network size while training. arXiv preprint arXiv:1806.03723, 2018. ",
+        "bbox": [
+            171,
+            728,
+            825,
+            758
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, John S Denker, and Sara A Solla. Optimal brain damage. In Advances in neural information processing systems, pp. 598–605, 1990. ",
+        "bbox": [
+            173,
+            767,
+            823,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. arXiv preprint arXiv:1608.08710, 2016. ",
+        "bbox": [
+            171,
+            804,
+            825,
+            834
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In Computer Vision (ICCV), 2017 IEEE International Conference on, pp. 2755–2763. IEEE, 2017. ",
+        "bbox": [
+            174,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christos Louizos, Karen Ullrich, and Max Welling. Bayesian compression for deep learning. In Advances in Neural Information Processing Systems, pp. 3290–3300, 2017. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. Variational dropout sparsifies deep neural networks. arXiv preprint arXiv:1701.05369, 2017. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pavlo Molchanov, Stephen Tyree, Tero Karras, Timo Aila, and Jan Kautz. Pruning convolutional neural networks for resource efficient transfer learning. arXiv preprint arXiv:1611.06440, 2016. ",
+        "bbox": [
+            171,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ari Morcos, David GT Barrett, Neil C Rabinowitz, and Matthew Botvinick. On the importance of single directions for generalization. In Proceeding of the International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            174,
+            178,
+            823,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vaishnavh Nagarajan and J Zico Kolter. Generalization in deep networks: The role of distance from initialization. arXiv preprint arXiv:1901.01672, 2019. ",
+        "bbox": [
+            173,
+            231,
+            823,
+            260
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sharan Narang, Gregory Diamos, Shubho Sengupta, and Erich Elsen. Exploring sparsity in recurrent neural networks. arXiv preprint arXiv:1704.05119, 2017. ",
+        "bbox": [
+            171,
+            267,
+            823,
+            297
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Behnam Neyshabur, Ryota Tomioka, and Nathan Srebro. In search of the real inductive bias: On the role of implicit regularization in deep learning. arXiv preprint arXiv:1412.6614, 2014. ",
+        "bbox": [
+            171,
+            305,
+            823,
+            335
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Behnam Neyshabur, Zhiyuan Li, Srinadh Bhojanapalli, Yann LeCun, and Nathan Srebro. Towards understanding the role of over-parametrization in generalization of neural networks. arXiv preprint arXiv:1805.12076, 2018. ",
+        "bbox": [
+            173,
+            343,
+            823,
+            386
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ben Poole, Jascha Sohl-Dickstein, and Surya Ganguli. Analyzing noise in autoencoders and deep networks. arXiv preprint arXiv:1406.1831, 2014. ",
+        "bbox": [
+            173,
+            395,
+            823,
+            424
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jorma Rissanen. Modeling by shortest data description. Automatica, 14(5):465–471, 1978. ",
+        "bbox": [
+            171,
+            433,
+            769,
+            448
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shai Shalev-Shwartz and Shai Ben-David. Understanding machine learning: From theory to algorithms. Cambridge university press, 2014. ",
+        "bbox": [
+            174,
+            457,
+            820,
+            486
+        ],
+        "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,
+            494,
+            823,
+            523
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            575
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhewei Yao, Amir Gholami, Qi Lei, Kurt Keutzer, and Michael W Mahoney. Hessian-based analysis of large batch training and robustness to adversaries. In Advances in Neural Information Processing Systems, pp. 4949–4959, 2018. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            627
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jianbo Ye, Xin Lu, Zhe Lin, and James Z Wang. Rethinking the smaller-norm-less-informative assumption in channel pruning of convolution layers. arXiv preprint arXiv:1802.00124, 2018. ",
+        "bbox": [
+            173,
+            635,
+            823,
+            665
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhonghui You, Jinmian Yan, Kun; Ye, Meng Ma, and Ping Wang. Gate decorator: Global filter pruning method for accelerating deep convolutional neural networks. In Advances in Neural Information Processing Systems, 2019. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            717
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ruichi Yu, Ang Li, Chun-Fu Chen, Jui-Hsin Lai, Vlad I Morariu, Xintong Han, Mingfei Gao, Ching-Yung Lin, and Larry S Davis. Nisp: Pruning networks using neuron importance score propagation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9194–9203, 2018. ",
+        "bbox": [
+            173,
+            724,
+            826,
+            781
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016. ",
+        "bbox": [
+            171,
+            790,
+            823,
+            820
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Zhu and Suyog Gupta. To prune, or not to prune: exploring the efficacy of pruning for model compression. arXiv preprint arXiv:1710.01878, 2017. ",
+        "bbox": [
+            171,
+            828,
+            823,
+            857
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            299,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/3b5e19e1693ec088e49d69b71323746c582fa9dffc86ae691f5f548228ce0e67.jpg",
+        "image_caption": [
+            "Figure A1: We examined the normalized activations (shown in blue histograms) of feature maps in the final eight convolutional layers of VGG19 before (left) and after (right) training to convergence. We found that the approximation to standard normality (shown in orange) of these activations is reasonable early on but degrades with training (particularly in layers near the output). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            369,
+            165,
+            629,
+            770
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The main drawback to the E[BN] approach (Section 3.1.1) is the sometimes poor approximation $M _ { i j } \\sim N ( \\beta , \\gamma )$ . In Figure A.1, the approximation’s quality depends on layer and training epoch. A less serious drawback is that this approach does not account for the strength of connections to the post-BN feature map, which could have activations with a large expected value but low importance if relatively small-magnitude weights connected the map to the following layer. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/33c01eafabc281b94017456ec830c848b3d07784a6a2164173bd46812fe2bac0.jpg",
+        "image_caption": [
+            "Figure A2: In VGG11, pruneS E[BN] is more stable than pruneS, which uses filter- $\\cdot \\ell _ { 2 }$ -norm to compare parameter magnitudes. Methods with higher iterative pruning rates create more instability on a given iteration. Means reduce along the run dimension (10 runs per configuration). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            140,
+            816,
+            406
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Note that this graph uses a method (pruneS) that was included in Figure 1 right, but was not displayed in Figure 1 left due to its similarity to pruneS E[BN]. Additional experimental details are in Section A.5.1. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            526
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/f7101c5956320628e4b182502af4a4ded6d93fb9d6d3371535b268180bcadae5.jpg",
+        "image_caption": [
+            "Figure A3: Pruning instability improves generalization of (Top) VGG11 and (Bottom) ResNet18 when training on CIFAR-10 (10 runs per configuration). (Left) Test accuracy during training of several models illustrates how adaptation to more unstable pruning leads to better generalization. (Right) Means reduce along the epoch dimension (creating one point per run-configuration combination). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            138,
+            818,
+            397
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Here we use the same training and pruning configurations that were used for Figure 1, but we replace E[BN] pruning with $\\ell _ { 2 }$ -norm pruning. Qualitatively, the two figures’ results are similar. Interestingly, though, the correlation between instability and generalization is somewhat weaker with $\\ell _ { 2 }$ -norm pruning. This may be explained by the fact that $\\ell _ { 2 }$ -norm pruning generates a narrower spectrum of instabilities, which is perhaps due to $\\ell _ { 2 }$ -norm scoring’s inability to accurately assess parameter importance (illustrated in Figure 4). ",
+        "bbox": [
+            173,
+            483,
+            825,
+            566
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/4dd6577d3a5cc3026da504cca8754b9736abde758832547e9c90af72c14ebc6c.jpg",
+        "image_caption": [
+            "Figure A4: When training Conv4 on CIFAR10, unstable pruning can significantly improve the baseline’s generalization. The training accuracies and test accuracies (the latter were calculated immediately after pruning) illustrate how much each pruning algorithm disturbs the neural network’s output during training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            336,
+            135,
+            658,
+            386
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "While it’s unclear how much unstable pruning, which is particularly damaging to capacity, can be sustained at high sparsity levels, prune $L$ can lead to generalization several percentage points above the baseline/prune $S$ when pruning $85 \\%$ of Conv4. Please see Section A.5.6 for experimental setup details. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            531
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.5 EXPERIMENTAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            393,
+            117
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Unstructured magnitude pruning entails removing individual weights (subsets of filters/neurons), which are selected for pruning based on their magnitude. Our unstructured pruning approach does not allow previously pruned weights to reenter the network (Narang et al., 2017; Zhu & Gupta, 2017; Gale et al., 2019). Structured magnitude pruning removes entire filters/neurons, which are selected based on their $\\ell _ { 2 }$ -norms or via the E[BN] calculation. Except where noted, we use structured pruning for VGG11 and ResNet18. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            215
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We denote the pruning of $n$ layers of a network by specifying a series of epochs at which pruning starts $s = ( s _ { 1 } , . . . , s _ { n } )$ , a series of epochs at which pruning ends $\\boldsymbol { e } = ( e _ { 1 } , . . . , e _ { n } )$ , a series of fractions of parameters to remove $p = ( p _ { 1 } , . . . , p _ { n } )$ , and an inter-pruning-iteration retrain period $r \\in \\mathbb N$ . For a given layer $l$ , the retrain period $r$ and fraction $p _ { l }$ jointly determine the iterative pruning percentage $i _ { l }$ . Our experiments prune the same number of parameters $i _ { l } \\times \\mathrm { s i z e } ( l a y e r _ { l } )$ per pruning iteration, ultimately removing $p _ { l } \\times 1 0 0 \\%$ of the parameters by the end of epoch $e _ { l }$ . ",
+        "bbox": [
+            174,
+            222,
+            825,
+            306
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Our approach is designed to study the effects of changing factors such as the iterative pruning rate and lacks some practically helpful features, e.g. hyperparameters indicating how many parameters can be safely pruned (Liu et al., 2017; Molchanov et al., 2017). When layerwise iterative pruning percentages differ (i.e., when there exists an $a$ and $b$ such that $i _ { a }$ and $i _ { b }$ are unequal), our figures state the largest iterative pruning rate that was used in any of the layers. ",
+        "bbox": [
+            174,
+            313,
+            825,
+            383
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "For ResNet, our pruning algorithms did not account for the magnitude of incoming shortcut connections when judging filter magnitude/importance. Though we did prune the incoming and outgoing shortcut connections associated with any pruned feature maps. ",
+        "bbox": [
+            176,
+            390,
+            823,
+            433
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We used only the CIFAR-10 dataset (Krizhevsky & Hinton, 2009) in our experiments, a limitation of our study. We used batch size 128, and only used data augmentation in the decile experiment (Figure 2). For some experiments, we give multi-step learning rate schedules $l r _ { s } = ( x , y )$ , which means we shrink the learning rate by a factor of 10 at epochs $x$ and $y$ . ",
+        "bbox": [
+            174,
+            438,
+            825,
+            496
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.5.1 FIGURE 1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            517,
+            299,
+            531
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We used E[BN] pruning in all models that were pruned, except for one model that used $\\ell _ { 2 }$ -norm magnitude pruning, which was included in Figure 1 right but not displayed in Figure 1 left due to its qualitative similarity to pruneS E[BN]. We leave out \"E[BN]\" in the legend of Figure 1 left, but all models nonetheless used E[BN] pruning. ",
+        "bbox": [
+            174,
+            544,
+            825,
+            601
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The models were trained on CIFAR-10 with Adam for 325 epochs with $l r _ { s } = ( 1 5 0 , 3 0 0 )$ . The error bars are $9 5 \\%$ confidence intervals for the mean, bootstrapped from 10 distinct runs of each experiment. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            648
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Since the layerwise pruning percentages varied, pruning required multiple iterative pruning percentages, the largest of which is denoted in the legend (rounded to the nearest integer). ",
+        "bbox": [
+            173,
+            656,
+            823,
+            684
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "VGG11 Pruning targeted the final four convolutional layers during training with (layerwise) starting epochs $s = ( 3 , 4 , 5 , 6 )$ , ending epochs $e = ( 1 5 0 , 1 5 0 , 1 5 0 , 2 7 5 )$ , and pruning fractions $p = ( 0 . 3 , 0 . 3 , 0 . 3 , 0 . 9 )$ . To allow for the same amount of pruning among models with differing iterative pruning percentages, we adjusted the number of inter-pruning retraining epochs. The models with the maximum iterative pruning percentage of $1 \\%$ had $r = 4$ , while the models with the maximum iterative pruning percentage of $13 \\%$ had $r = 4 0$ . The model pruned with $\\ell _ { 2 }$ -norm magnitude pruning, which only appeared in Figure 1 right, had $r = 4$ as well. ",
+        "bbox": [
+            173,
+            707,
+            825,
+            804
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "ResNet18 Pruning targeted the final four convolutional layers of ResNet18 during training with (layerwise) starting epochs $s = ( 3 , 4 , 5 , 6 )$ , ending epochs $e = ( 1 5 0 , 1 5 0 , 1 7 0 , 2 7 5 )$ , and pruning fractions $p = ( 0 . 2 5 , 0 . 4 , 0 . 2 5 , 0 . 9 5 )$ . As noted in Section 4.1, we increased the pruning rate of the output layer of the penultimate block to remove shortcut connections to the last layer, thinking that it should increase the duration of adaptation to pruning. The models with the maximum iterative pruning percentage of $1 \\%$ had $r = 4$ , while the models with the maximum iterative pruning percentage of $13 \\%$ had $r = 4 0$ . ",
+        "bbox": [
+            174,
+            825,
+            825,
+            922
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.5.2 FIGURE 2 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            299,
+            117
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Each experiment in Figure 2 targeted one of ten weight-magnitude deciles in the post-convolutional linear layer of the Conv4 network during training on CIFAR-10 with data augmentation. ",
+        "bbox": [
+            174,
+            131,
+            823,
+            160
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "While there are just ten deciles, the iterative nature of our pruning algorithms required the creation of eleven different pruning targets: ten methods pruned from the bottom of the decile upward (one experiment for each decile’s starting point: 0th percentile, 10th percentile, etc.), and one (D10) pruned from the last decile’s ending point downward (pruning the very largest collection of weights each iteration). In other words, D9 and D10 targeted the same decile (90th percentile to maximum value), but only D10 actually removed the largest weights on a given iteration (weights in the 100th-99th percentiles, for example). The D9 experiment would target weights starting from the 90th percentile (e.g. it may prune the 90th-91st percentiles on a particular iteration). ",
+        "bbox": [
+            173,
+            166,
+            825,
+            279
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "The training/pruning setup used the Adam optimizer, $s = ( 4 )$ , $e = ( 5 2 )$ , $p = ( 0 . 1 )$ , $r = 3$ , and $l r _ { s } = ( 3 0 , \\bar { 6 } 0 )$ . We calculated the generalization gap on epoch 54 and sampled average pruned magnitudes on epoch 35. We obtained qualitatively similar results regardless of whether we used fewer training epochs or data augmentation. The error bars are $9 5 \\%$ confidence intervals for the means, bootstrapped from 10 distinct runs of each configuration. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            354
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "A.5.3 FIGURE 3 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            378,
+            299,
+            392
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "In Figure 3, prune $\\mathrm { L }$ was applied to the final four convolutional layers of ResNet18 during training with (layerwise) starting epochs $s = ( 3 , 4 , 5 , 6 )$ , ending epochs $e = ( 1 5 0 , 1 5 0 , 1 7 0 , 2 7 5 )$ , and pruning fractions $p = ( 0 . 2 5 , 0 . 4 , 0 . 2 5 , 0 . 9 5 )$ . Since the layerwise pruning percentages varied, pruning required multiple iterative pruning percentages, the largest of which is denoted in the legend (rounded to the nearest integer). The models with the maximum iterative pruning percentage of $1 \\%$ had $r = 4$ , the models with the maximum iterative pruning percentage of $13 \\%$ had $r = 4 0$ , and the \"One Shot\" model pruned all its targeted parameters at once on epoch 246. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            505
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "When performing unstructured pruning, we pruned individual weights from filters based on their magnitude. The structured pruning experiments used E[BN] pruning. ",
+        "bbox": [
+            176,
+            511,
+            820,
+            540
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "The models were trained on CIFAR-10 with Adam for 325 epochs with $l r _ { s } = ( 1 5 0 , 3 0 0 )$ . The error bars are $9 5 \\%$ confidence intervals for the means, bootstrapped from 10 distinct runs of each experiment. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            588
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "A.5.4 FIGURE 4 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            613,
+            299,
+            627
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "In Figure 4, pruning targeted the final four convolutional layers of VGG11 during training with (layerwise) starting epochs $s = ( 3 , 4 , 5 , 6 )$ , ending epochs $e = ( 1 5 0 , 1 5 0 , 1 5 0 , 2 7 5 )$ , and pruning fractions $p = ( 0 . 3 , 0 . 3 , 0 . 3 , 0 . 9 )$ . To create the different iterative pruning rates, we used models with inter-pruning retrain periods $r = 4$ , $r = 2 0$ , $r = 4 0$ , $r = 6 0$ , and $r = 1 0 0$ . Since the layerwise pruning percentages varied, pruning required multiple iterative pruning percentages, the largest of which is denoted on the horizontal axis. An unpruned baseline model average (10 runs) is plotted on the dotted line. ",
+        "bbox": [
+            174,
+            641,
+            825,
+            738
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "The models were trained on CIFAR-10 with Adam for 325 epochs with $l r _ { s } = ( 1 5 0 , 3 0 0 )$ . The error bars are $9 5 \\%$ confidence intervals for the means, bootstrapped from 10 distinct runs of each experiment. ",
+        "bbox": [
+            174,
+            744,
+            825,
+            787
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "A.5.5 FIGURE 5 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            811,
+            299,
+            827
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "In Figure 5, pruning targeted the final four convolutional layers of VGG11 during training with (layerwise) starting epochs $s = ( 3 , 4 , 5 , 6 )$ , ending epochs $e = ( 1 5 0 , 1 5 0 , 1 5 0 , 2 7 5 )$ , pruning fractions $p = ( 0 . 3 , 0 . 3 , \\bar { 0 } . 3 , 0 . 9 )$ , and inter-pruning-iteration retrain period $r = 4 0$ . When injecting pruning noise, we used the same pruning schedule and percentages, but applied noise to the parameters instead of removing them. The Gaussian noise had mean 0 and standard deviation equal to the empirical standard deviation of a noiseless filter from the same layer. Prune $\\mathrm { L }$ used $\\ell _ { 2 }$ -norm pruning. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "The models were trained on CIFAR-10 with Adam for 325 epochs with $l r _ { s } = ( 1 5 0 , 3 0 0 )$ . The error bars are $9 5 \\%$ confidence intervals for the means, bootstrapped from 10 distinct runs of each experiment. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "A.5.6 APPENDIX A.4 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            161,
+            334,
+            175
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Each experiment in Appendix A.4 targeted the post-convolutional linear layer of the Conv4 network during training on CIFAR-10 with the Adam optimizer. The pruning algorithms start on epoch $s = ( 3 )$ , end on epoch $e = ( 1 8 )$ , prune the percentage $p = ( 0 . 9 )$ , and prune every epoch via retrain period $r = 1$ . These relatively simple experiments were conducted to show that, at higher sparsity (pruning $85 \\%$ of the model’s parameters), unstable pruning can improve the generalization of the baseline. The error bars are $9 5 \\%$ confidence intervals for the means, bootstrapped from 20 distinct runs of each configuration. ",
+        "bbox": [
+            174,
+            185,
+            825,
+            284
+        ],
+        "page_idx": 17
+    }
+]

parse/train/FMPuzXV1fR/FMPuzXV1fR.md

@@ -0,0 +1,329 @@
+# Breaking the centralized barrier for cross-device federated learning∗
+
+Sai Praneeth Karimireddy EPFL sai.karimireddy@epfl.ch
+
+Martin Jaggi EPFL martin.jaggi@epfl.ch
+
+Satyen Kale Google Research satyenkale@google.com
+
+Mehryar Mohri Google Research mohri@google.com
+
+Sashank J. Reddi Google Research sashank@google.com
+
+Sebastian U. Stich EPFL sebastian.stich@epfl.ch
+
+Ananda Theertha Suresh Google Research theertha@google.com
+
+# Abstract
+
+Federated learning (FL) is a challenging setting for optimization due to the heterogeneity of the data across different clients which can cause a client drift phenomenon. In fact, designing an algorithm for FL that is uniformly better than simple centralized training has been a major open problem thus far. In this work, we propose a general algorithmic framework, MIME, which i) mitigates client drift and ii) adapts an arbitrary centralized optimization algorithm such as momentum and Adam to the cross-device federated learning setting. MIME uses a combination of control-variates and server-level optimizer state (e.g. momentum) at every client-update step to ensure that each local update mimics that of the centralized method run on i.i.d. data. We prove a reduction result showing that MIME can translate the convergence of a generic algorithm in the centralized setting into convergence in the federated setting. Moreover, we show that, when combined with momentum-based variance reduction, MIME is provably faster than any centralized method–the first such result. We also perform a thorough experimental exploration of MIME’s performance on real world datasets (implemented here).
+
+# 1 Introduction
+
+Federated learning (FL) is an increasingly important large-scale learning framework where the training data remains distributed over a large number of clients, which may be mobile phones or network sensors [38, 37, 43, 44, 28]. A server then orchestrates the clients to train a single model, here referred to as a server model, without ever transmitting client data over the network, thereby providing some basic levels of data privacy and security.
+
+Two important settings are distinguished in FL [28, Table 1]: the cross-device and the cross-silo settings. The cross-silo setting corresponds to a relatively small number of reliable clients, typically organizations, such as medical or financial institutions. In contrast, in the cross-device federated learning setting, the number of clients may be extremely large and include, for example, all 3.5 billion active android phones [25]. Thus, in that setting, we may never make even a single pass over the entire clients’ data during training. The cross-device setting is further characterized by resourcepoor clients communicating over a highly unreliable network. Together, the essential features of this setting give rise to unique challenges not present in the cross-silo setting. In this work, we are interested in the more challenging cross-device setting, for which we will formalize and study stochastic optimization algorithms. Importantly, recent advances in FL optimization, such as SCAFFOLD [32] or FedDyn [1], are not anymore applicable since they are designed for the cross-silo setting.
+
+The problem. The de facto standard algorithm for the cross-device setting is FEDAVG [43], which performs multiple SGD updates on the available clients before communicating to the server. While this approach can reduce the frequency of communication required, performing multiple steps on the same client can lead to ‘over-fitting’ to its atypical local data, a phenomenon known as client drift [32]. This in turn leads to slower convergence and can, somewhat counter-intuitively, require larger total communication [69]. Despite significant attention received from the optimization community, the communication complexity of heterogeneous cross-device has not improved upon that of simple centralized methods, which take no local steps (aka SERVER-ONLY methods). Furthermore, algorithmic innovations such as momentum [59, 14], adaptivity [35, 75, 77], and clipping [71, 72, 76] are critical to the success of deep learning applications. The lack of a theoretical understanding of the impact of multiple client steps has also hindered adapting these techniques in a principled manner into the client updates, in order to replace the vanilla SGD update of FEDAVG.
+
+To overcome such deficiencies, we propose a new framework, MIME, that mitigates client drift and can adapt an arbitrary centralized optimization algorithm, e.g. SGD with momentum or Adam, to the federated setting. In each local client update, MIME uses global optimizer state, e.g. momentum or adaptive learning rates, and an SVRG-style correction to mimic the updates of the centralized algorithm run on i.i.d. data. This optimizer state is computed only at the server level and kept fixed throughout the local steps, thereby avoiding overfitting to the atypical local data of any single client.
+
+Contributions. We summarize our main results below.
+
+• MIME framework. We formalize the cross-device federated learning problem, and propose a new framework MIME that can adapt arbitrary centralized algorithms to this setting. • Convergence result. We prove a result showing that MIME successfully reduces client drift. We also prove that the convergence of any generic algorithm in the centralized setting translates convergence of its MIME version in the federated setting. • Speed-up over centralized methods. By carefully tracking the bias introduced due to multiple local steps, we prove that MIME with momentum-based variance reduction (MVR) can beat a lower bound for centralized methods, thus breaking a fundamental barrier. This is the first such result in FL, and also the first general result showing asymptotic speed-up due to local steps. • Empirical validation. We propose a simpler variant, MIMELITE, with an empirical performance similar to MIME. We report the results of thorough experimental analysis demonstrating that both MIME and MIMELITE indeed converge faster than FEDAVG.
+
+Related work. Analysis of FEDAVG: Much of the recent work in federated learning has focused on analyzing FEDAVG. For identical clients, FEDAVG coincides with parallel SGD, for which [78] derived an analysis with asymptotic convergence. Sharper and more refined analyses of the same method, sometimes called local SGD, were provided by [56], and more recently by [57], [47], [34], and [70], for identical functions. Their analysis was extended to heterogeneous clients in [68, 74, 32, 34, 36]. [11] derived a tight characterization of FedAvg with quadratic functions and demonstrated the sensitivity of the algorithm to both client and server step sizes. Matching upper and lower bounds were recently given by [32] and [69] for general functions, proving that FEDAVG can be slower than even SGD for heterogeneous data, due to the client-drift.
+
+Comparison to SCAFFOLD: For the cross-silo setting where the number of clients is relatively low, [32] proposed the SCAFFOLD algorithm, which uses control-variates (similar to SVRG) to correct for client drift. However, their algorithm crucially relies on stateful clients which repeatedly participate in the training process. FedDyn [1] reduces the communication requirements, but also requires persistent stateful clients. In contrast, we focus on the cross-device setting where clients may be visited only once during training and where they are stateless (and thus SCAFFOLD and FedDyn are inapplicable). This is akin to the difference between the finite-sum (corresponding to cross-silo) and stochastic (cross-device) settings in traditional centralized optimization [39].
+
+Comparison to FedAvg and variants: [26] and [67] observed that using server momentum significantly improves over vanilla FEDAVG. This idea was generalized by [49], who replaced the server update with an arbitrary optimizer, e.g. Adam. However, these methods only modify the server update while using SGD for the client updates. We henceforth refer to this meta algorithm as FedAvg. FedAvgSGD, FedAvgMom, FedAvgAdam denote specific instantiations of the server optimizer in FedAvg with SGD, Momentum or Adam. MIME, on the other hand, ensures that every local client update resembles the optimizer e.g. MIME would apply momentum in every client update and not just at the server level. Beyond this, [40] proposed to add a regularizer to ensure client updates remain close. However, this may slow down convergence (cf. Fig. 5 and [32, 66]). Other orthogonal directions which can be combined with MIME include tackling computation heterogeneity, where some clients perform many more updates than others [66], improving fairness by modifying the objective [44, 41], incorporating differential privacy [20, 2, 61], Byzantine adversaries [48, 65, 30], secure aggregation [8, 24], etc. We defer additional discussion to the extensive survey by [28].
+
+Momentum based variance reduction. Initial optimal methods for stochastic non-convex optimization like SPIDER [17] and SARAH [46] required intermittently computing very large batch gradients. Subsequently, it was shown that momentum based variance reduction (MVR) methods obtained a similar optimal rate without needing such large batch gradient computations [62, 14]. Momentum is an exponential moving average of many stochastic gradients and so it has much smaller variance than the stochastic gradients themselves. However, because these gradients are computed at different parameters it also has a bias. MVR adds a small additional correction term which significantly reduces this bias and provides improved rates.
+
+# 2 Problem setup
+
+This section formalizes the problem of cross-device federated learning [28]. Cross-device FL is characterized by a large number of client devices like mobile phones which may potentially connect to the server at most once. Due to their transient nature, it is not possible to store any state on the clients, precluding an algorithm like SCAFFOLD. Furthermore, each client has only a few samples, and there is wide heterogeneity in the samples across clients. Finally, communication is a major bottleneck and a key metric for optimization in this setting is the number of communication rounds.
+
+Thus, our objective will be to minimize the following quantity within the fewest number of clientserver communication rounds:
+
+$$
+f ( \pmb { x } ) = \mathbb { E } _ { i \sim \mathcal { C } } \Big [ f _ { i } ( \pmb { x } ) : = \frac { 1 } { n _ { i } } \sum _ { \nu = 1 } ^ { n _ { i } } f _ { i } ( \pmb { x } ; \zeta _ { i , \nu } ) \Big ] .
+$$
+
+Here, $f _ { i }$ denotes the loss function of client $i$ and $\{ \zeta _ { i , 1 } , \ldots , \zeta _ { i , n _ { i } } \}$ its local data. Since the number of clients is extremely large, while the size of each local data is rather modest, we represent the former as an expectation and the latter as a finite sum. In each round, the algorithm samples a subset of clients (of size $S$ ) and performs some updates to the server model. Due to the transient and heterogeneous nature of the clients, it is easy to see that the problem becomes intractable with arbitrarily dissimilar clients. Thus, it is necessary to assume bounded dissimilarity across clients.
+
+(A1) $G ^ { 2 }$ -BGV or bounded inter-client gradient variance: there exists $G \geq 0$ such that
+
+$$
+\begin{array} { r } { \mathbb { E } _ { i \sim \mathcal { C } } [ \| \nabla f _ { i } ( \pmb { x } ) - \nabla f ( \pmb { x } ) \| ^ { 2 } ] \le G ^ { 2 } , \forall \pmb { x } . } \end{array}
+$$
+
+Next, we also characterize the variance in the Hessians.
+
+(A2) $\delta$ -BHV or bounded Hessian variance: Almost surely, the loss function of any client $i$ satisfies
+
+$$
+\begin{array} { r } { \| \nabla ^ { 2 } f _ { i } ( { \pmb x } ; \zeta ) - \nabla ^ { 2 } f ( { \pmb x } ) \| \leq \delta , \forall { \pmb x } . } \end{array}
+$$
+
+This is in contrast to the usual smoothness assumption that can be stated as:
+
+$( \mathbf { A } 2 ^ { * } )$ ) $L$ -smooth: $\| \nabla ^ { 2 } f _ { i } ( \pmb { x } ; \zeta ) \| \le L$ , $\forall x$ , a.s. for any $i$ .
+
+Note that if $f _ { i } ( x ; \zeta )$ is $L$ -smooth then (A2) is satisfied with $\delta \leq 2 L$ , and hence (A2) is weaker than $( \mathsf { A } 2 ^ { \ast } )$ . In realistic examples we expect the clients to be similar and hence that $\delta \ll L$ . In addition, we assume that $f ( { \pmb x } )$ is bounded from below by $f ^ { \star }$ and is $L$ -smooth, as is standard.
+
+# 3 Mime framework
+
+In this section we describe how to adapt an arbitrary centralized optimizer (referred to as the “base” optimizer) which may have internal state (e.g. momentum) to the federated learning problem (1) while ensuring there is no client-drift. Algorithm 4 describes our framework. We develop two variants, MIME and MIMELITE, which consist of three components i) a base optimizer we are seeking to mimic, ii) the global (server) optimizer state computation, and iii) the local client updates.
+
+# Algorithm 1 Mime and MimeLite
+
+<table><tr><td>input: initial x and s,learning rate η and base optimize B= (U,V) for each round t = 1,..,T do sample subset S of clients</td></tr><tr><td>communicate (x, s) to all clients i ∈ S communicate c ←  ∑j∈s Vf(x) (only Mime)</td></tr><tr><td>on client i ∈ S in parallel do initialize local model yi ←x for k=1,.,K do</td></tr><tr><td>sample mini-batch ‘ from local data gi ← Vfi(yi;S)-Vfi(x;S)+c (Mime)</td></tr><tr><td>gi ←Vfi(yi; S) (MimeLite)</td></tr><tr><td>update yi ← yi - nu(gi,s) end for</td></tr><tr><td>compute full local-batch gradient Vfi(x) communicate (yi, Vf (x))</td></tr><tr><td>end on client</td></tr><tr><td>8 ← V(ΣiesVfi(x),s) (update optimize state)</td></tr><tr><td>x ← ∑i∈s yi (update server parameters) end for</td></tr></table>
+
+Base optimizer. We assume the centralized base optimizer we are imitating can be decomposed into two steps: an update step $\mathcal { U }$ which updates the parameters $_ { \textbf { \em x } }$ , and a optimizer state update step $\mathcal { V } ( \cdot )$ which keeps track of global optimizer state $\pmb { s }$ . Each step of the base optimizer $\boldsymbol { B } = ( \boldsymbol { \mathcal { U } } , \boldsymbol { \mathcal { V } } )$ uses a gradient $\textbf {  { g } }$ to update the parameter $_ { \textbf { \em x } }$ and the optimizer state $\pmb { s }$ as follows:
+
+$$
+\begin{array} { l } { { { \pmb x }  { \pmb x } - \eta \mathcal { U } ( { \pmb g } , { \pmb s } ) , } } \\ { { { \pmb s }  \mathcal { V } ( { \pmb g } , { \pmb s } ) . } } \end{array}
+$$
+
+As an example, consider SGD with momentum. The state here is the momentum ${ \mathbf { } } m _ { t }$ and uses the following update steps:
+
+$$
+\begin{array} { r l } & { \pmb { x } _ { t } = \pmb { x } _ { t - 1 } - \eta \left( ( 1 - \beta ) \nabla f _ { i } ( \pmb { x } _ { t - 1 } ) \right. } \\ & { \qquad \quad + \left. \beta \pmb { m } _ { t - 1 } \right) , } \\ & { \pmb { m } _ { t } = ( 1 - \beta ) \nabla f _ { i } ( \pmb { x } _ { t - 1 } ) + \beta \pmb { m } _ { t - 1 } . } \end{array}
+$$
+
+Thus, SGD with momentum can be represented in the above generic form with $\mathcal { U } ( { \pmb g } , { \pmb s } ) = ( 1 - \beta ) { \overset { } { \pmb g } } + \beta { \pmb s }$ and $\mathcal { V } ( { \pmb g } , \pmb s ) = ( 1 - \beta ) \pmb { g } + \beta \pmb { s }$ . Table 5 in Appendix shows how other algo
+
+rithms like Adam, Adagrad, etc. can be represented in this manner. We keep the update $\mathcal { U }$ to be linear in the gradient $\textbf {  { g } }$ , whereas $\nu$ can be more complicated. This implies that while the parameter update step $\mathcal { U }$ is relatively resilient to receiving a biased gradient $\textbf {  { g } }$ while $\nu$ can be much more sensitive.
+
+Compute optimizer state globally, apply locally. When updating the optimizer state of the base algorithm, we use only the gradient computed at the server parameters. Further, they remain fixed throughout the local updates of the clients. This ensures that these optimizer state remain unbiased and representative of the global function $f ( \cdot )$ . At the end of the round, the server performs
+
+$$
+\begin{array} { r l } & { \boldsymbol { s } \gets \mathcal { V } \Big ( \frac { 1 } { | \mathcal { S } | } \sum _ { i \in \mathcal { S } } \nabla f _ { i } ( \boldsymbol { x } ) , \boldsymbol { s } \Big ) , } \\ & { \nabla f _ { i } ( \boldsymbol { x } ) = \frac { 1 } { n _ { i } } \sum _ { \nu = 1 } ^ { n _ { i } } \nabla f _ { i } ( \boldsymbol { x } ; \zeta _ { i , \nu } ) . } \end{array}
+$$
+
+Note that we use full-batch gradients computed at the server parameters $_ { \textbf { \em x } }$ , not client parameters $\mathbf { \nabla } _ { \mathbf { \psi } _ { 3 } } \psi _ { i }$
+
+Local client updates. Each client $i \in S$ performs $K$ updates using $\mathcal { U }$ of the base algorithm and a minibatch gradient. There are two variants possible corresponding to $\mathbf { M M E }$ and MIMELITE differentiated using colored boxes. Starting from ${ \pmb y } _ { i }  { \pmb x }$ , repeat the following $K$ times
+
+$$
+{ \pmb y } _ { i } \gets { \pmb y } _ { i } - \eta \mathcal { U } ( { \pmb g } _ { i } , { \pmb s } )
+$$
+
+where $\pmb { g } _ { i } \gets \nabla f _ { i } ( \pmb { y } _ { i } ; \zeta )$ for MIMELITE, and $\begin{array} { r } { \pmb { g } _ { i }  \nabla f _ { i } ( \pmb { y } _ { i } ; \zeta ) - \nabla f _ { i } ( \pmb { x } ; \zeta ) + \frac { 1 } { | \mathcal { S } | } \sum _ { j \in \mathcal { S } } \nabla f _ { j } ( \pmb { x } ) } \end{array}$ for MIME. MIMELITE simply uses the local minibatch gradient whereas MIME uses an SVRG
+
+style correction [27]. This is done to reduce the noise from sampling a local mini-batch. While this correction yields faster rates in theory (and in practice for convex problems), in deep learning applications we found that MIMELITE closely matches the performance of MIME.
+
+Finally, there are two modifications made in practical FL: we weight all averages across the clients by the number of datapoints $n _ { i }$ [43], and we perform $K$ epochs instead of $K$ steps [66].
+
+# 4 Theoretical analysis of Mime
+
+Table 1 summarizes the rates of MIME (highlighted in blue) and MIMELITE (highlighted in green) and compares them to SERVER-ONLY methods when using SGD, Adam and momentum methods as the base algorithms. We will first examine the convergence of MIME and MIMELITE with a generic base optimizer and show that its properties are preserved in the federated setting. We then examine a specific momentum based base optimizer, and prove that Mime and MimeLite can be asymptotically faster than the best server-only method. This is the first result to prove the usefulness of local steps and demonstrate asymptotic speed-ups.
+
+# 4.1 Convergence with a generic base optimizer
+
+We will prove a generic reduction result demonstrating that if the underlying base algorithm converges, and is robust to slight perturbations, then MIME and MIMELITE also preserve the convergence of the algorithm when applied to the federated setting with additinoal local steps.
+
+Theorem I. Suppose that we have $G ^ { 2 }$ inter-client gradient variance (A1), $L$ -smooth $\left\{ f _ { i } \right\} \left( \mathbf { A } 2 ^ { * } \right)$ , and $\sigma ^ { 2 }$ intra-client gradient variance (A3). Further, suppose that the updater $\mathcal { U }$ of our baseoptimizer $\boldsymbol { B } = ( \boldsymbol { \mathcal { U } } , \boldsymbol { \mathcal { V } } )$ satisfies i) linearity for a fixed state s: $\mathcal { U } ( \pmb { g } _ { 1 } + \pmb { g } _ { 2 } ; \pmb { s } ) = \mathcal { U } ( \pmb { g } _ { 1 } ; \pmb { s } ) + \mathcal { U } ( \pmb { g } _ { 2 } ; \pmb { s } )$ , and ii) Lipschitzness: $\| \mathcal { U } ( \pmb { g } ; \pmb { s } ) \| \leq B \| \pmb { g } \|$ for some $B \geq 0$ . Then, running MIME $o r$ MIMELITE with $K$ local updates and step-size $\eta$ is equivalent to running a centralized algorithm with step-size $\begin{array} { r } { \tilde { \eta } : = K \eta \le \frac { \hat { 1 } } { 2 L B } } \end{array}$ , and updates
+
+$$
+\pmb { x } _ { t }  \pmb { x } _ { t - 1 } - \tilde { \eta } \mathcal { U } ( \pmb { g } _ { t } + \pmb { e } _ { t } , \pmb { s } _ { t - 1 } ) , a n
+$$
+
+an unbiased gradient $\mathbb { E } _ { t } [ { \pmb { g } } _ { t } ] = \nabla f ( { \pmb { x } } _ { t - 1 } )$ , with variance bounded as
+
+$$
+\begin{array} { r } { \mathbb { E } _ { t } \Vert { \pmb { g } } _ { t } - \nabla f ( { \pmb x } _ { t - 1 } ) \Vert ^ { 2 } \leq \left\{ \begin{array} { l l } { \frac { G ^ { 2 } } { S } } & { \mathrm { ~ M I M E ~ } , } \\ { \frac { G ^ { 2 } } { S } + \frac { \sigma ^ { 2 } } { K S } } & { \mathrm { ~ M I M E L I T E ~ } . } \end{array} \right. } \end{array}
+$$
+
+and finally a small error bounded as
+
+$$
+\begin{array} { r } { \frac { 1 } { B ^ { 2 } L ^ { 2 } \tilde { \eta } ^ { 2 } } \mathbb { E } _ { t } \Vert e _ { t } \Vert ^ { 2 } \leq \left\{ \begin{array} { l l } { \mathbb { E } _ { t } \Vert g _ { t } \Vert ^ { 2 } } & { \mathrm { ~ M I M E ~ , } } \\ { \mathbb { E } _ { t } \Vert g _ { t } \Vert ^ { 2 } + G ^ { 2 } + \frac { \sigma ^ { 2 } } { K } } & { \mathrm { ~ M I M E L I T E ~ . } } \end{array} \right. } \end{array}
+$$
+
+Here, we have proven that MIME and MIMELITE truly mimic the centralized base algorithm with very small perturbations—the magnitude of $e _ { t }$ is $\mathcal { O } ( \bar { \eta } ^ { 2 } )$ . The key to the result is the linearity of the parameter update step $\mathcal { U } ( \cdot ; s )$ . By separating the base optimizer into a very simple parameter step $\mathcal { U }$ and a more complicated optimizer state update step $\nu$ , we can ensure that commonly used algorithms such as momentum, Adam, Adagrad, and others all satisfy this property. Armed with this general reduction, we can easily obtain specific convergence results.
+
+Corollary $\mathbf { I I }$ ((Mime/MimeLite) with SGD). Given that the conditions in Theorem $I$ are satisfied, let us run $T$ rounds with $K$ local steps using SGD as the base optimizer and output ${ \pmb x } ^ { o u t }$ . This output satisfies $\mathbb { E } \| \nabla f ( \pmb { x } ^ { o u t } ) \| ^ { 2 } \leq \epsilon$ for $F : = f ( \pmb { x } _ { 0 } ) - f ^ { \star }$ , $\tilde { G } ^ { 2 } : = G ^ { 2 } \stackrel { \sim } { + } \sigma ^ { 2 } / K$ and
+
+• $\mu$ -PL inequality: $\begin{array} { r } { \eta = \tilde { \mathcal { O } } \big ( \frac { 1 } { \mu K T } \big ) } \end{array}$ , and
+
+$$
+\begin{array} { r l } & { T = \left\{ \begin{array} { l l } { \tilde { \mathcal { O } } \left( \frac { L G ^ { 2 } } { \mu S \epsilon } + \frac { L F } { \mu } \log \left( \frac { 1 } { \epsilon } \right) \right) } & { \mathrm { ~ M I M E ~ } , } \\ { \tilde { \mathcal { O } } \left( \frac { L G ^ { 2 } } { \mu S \epsilon } + \frac { L \tilde { \mathcal { G } } } { \mu \sqrt { \epsilon } } + \frac { L F } { \mu } \log \left( \frac { 1 } { \epsilon } \right) \right) } & { \mathrm { ~ M I M E L I T E ~ } . } \end{array} \right. } \\ & { = \mathcal { O } \big ( \sqrt { \frac { F S } { L G ^ { 2 } T K ^ { 2 } } } \big ) , a n d } \\ & { T = \left\{ \begin{array} { l l } { \mathcal { O } \Big ( \frac { L G ^ { 2 } F } { S \epsilon ^ { 2 } } + \frac { L F } { \epsilon } \Big ) } & { \mathrm { ~ M I M E ~ } , } \\ { \mathcal { O } \Big ( \frac { L G ^ { 2 } F } { S \epsilon ^ { 2 } } + \frac { L ^ { 2 } G F } { \epsilon ^ { 3 / 2 } } + \frac { L F } { \epsilon } \Big ) } & { \mathrm { ~ M I M E L I T E ~ } . } \end{array} \right. } \end{array}
+$$
+
+Table 1: Number of communication rounds required to reach $\| \nabla f ( \pmb { x } ) \| ^ { 2 } \leq \epsilon$ (log factors are ignored) with $S$ clients sampled each round. All analyses except SCAFFOLD assume $G ^ { 2 }$ bounded gradient dissimilarity (A1). All analyses assume $L$ -smooth losses, except MimeLiteMVR and MimeMVR, which only assume $\delta$ bounded Hessian dissimilarity (A2). Convergence of SCAFFOLD depends on the total number of clients $N$ which is potentially infinite. FEDAVG and MIMELITE are slightly slower than the server-only methods due to additional drift terms in most cases. MIME is the fastest and either matches or improves upon the optimal statistical rates (first term in the rates). In fact, MimeMVR and MimeLiteMVR beat lower bounds for any server-only method when $\delta \ll L$ .   
+
+<table><tr><td>Algorithm</td><td colspan="5">Non-convex</td><td colspan="4"> μ-PL inequality</td></tr><tr><td colspan="2">SCAFFOLDa [32]</td><td colspan="4">2 （） L E</td><td>+</td><td colspan="3"></td></tr><tr><td colspan="2">SGD SERVER-ONLY [21]</td><td colspan="4">LG² +</td><td>G²</td><td>+</td><td></td><td></td></tr><tr><td>MimeLiteSGD=</td><td>FedAvgSGD C</td><td colspan="2">S E LG² L²G</td><td>+</td><td></td><td>uSe G²</td><td>+</td><td>μ LG</td><td>+/</td></tr><tr><td>MimeSGD</td><td></td><td>S+ LG² +</td><td>3/2 L</td><td></td><td>μSE G²</td><td></td><td>L</td><td>HVE</td><td>μ</td></tr><tr><td>ADAM</td><td></td><td>Se² L</td><td>E</td><td></td><td></td><td>μSE</td><td>+ μ</td><td></td><td></td></tr><tr><td></td><td>SERVER-ONLY [75]b</td><td colspan="4">-G2/s</td><td></td><td></td><td></td><td></td></tr><tr><td>MimeAdamb</td><td>MimeLiteAdambc</td><td colspan="4">LVS E-G2/S</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td colspan="4">L e-G²/S</td><td></td><td></td><td></td><td></td></tr><tr><td>SERVER-ONLY [14]</td><td>Momentum Variance Reduction (MVR)</td><td colspan="4">LG G + S3/2</td><td></td><td></td><td></td><td></td></tr><tr><td>MimeLiteMVRd</td><td></td><td colspan="4">Se E δ(G+σ) G²+² 8</td><td></td><td></td><td></td><td></td></tr><tr><td>MimeMVRd</td><td></td><td colspan="4">3/2 E E 8G G²</td><td></td><td></td><td></td><td></td></tr><tr><td colspan="2">SERVER-ONLY lower bound [5]</td><td>VSe3/2 2（</td><td>十 SE LG G²</td><td>E +）</td><td>2（）</td><td></td><td></td><td></td><td></td></tr></table>
+
+a Num. clients $. N )$ can be same order as num. total rounds or even $\infty$ , making the bounds vacuous. b Adam requires large batch-size $S \ge G ^ { 2 } / \epsilon$ to converge [50, 75]. Convergence of FedAdam with client sampling is unknown ([49] only analyze with full client participation). c Requires $K \stackrel { \smile } { \geq } \sigma ^ { 2 } / G ^ { 2 }$ number of local updates. Typically, intra-client variance is small $( \sigma ^ { 2 } \lesssim G ^ { 2 } )$ . d Requires $K \ge L / \delta$ number of local updates. Faster than the lower bound (and hence any SERVERONLY algorithm) when $\delta \ll L$ i.e. our methods can take advantage of Hessian similarity, whereas SERVER-ONLY methods cannot. In worst case, $\delta \approx L$ and all methods are comparable.
+
+If we take a sufficient number of local steps $K \ge G ^ { 2 } / \sigma ^ { 2 }$ , then we have ${ \tilde { G } } = { \mathcal { O } } ( G )$ in the above rates. On comparing with the rates in Table 1 for SERVER-ONLY SGD, we see that MIME exactly matches its rates. MIMELITE matches the asymptotic term but has a few higher order terms. Note that when using SGD as the base optimizer, MIMELITE becomes exactly the same as FEDAVG and hence has the same rate of convergence.
+
+Corollary III ((Mime/MimeLite) with Adam). Suppose that the conditions in Theorem $I$ are satisfied, and further $| \nabla _ { j } f _ { i } ( { \pmb x } ) | \le H$ for any coordinate $j \in [ d ]$ . Then let us run $T$ rounds using Adam as the base optimizer with $K$ local steps, $\beta _ { 1 } = 0$ , $\varepsilon _ { 0 } > 0$ , $\eta \leq \varepsilon _ { 0 } ^ { 2 } / K L ( H + \varepsilon _ { 0 } )$ , and any $\beta _ { 2 } \in [ 0 , 1 )$ . Output ${ \pmb x } ^ { o u t }$ chosen randomly from $\{ \pmb { x } _ { 1 } , \hdots \pmb { x } _ { T } \}$ satisfies $\mathbb { E } \| \nabla f ( \pmb { x } ^ { o u t } ) \| ^ { 2 } \leq \epsilon _ { \mathcal { I } }$ for
+
+$$
+\begin{array} { r l } & { T = \left\{ \begin{array} { l l } { \mathcal { O } \Big ( \frac { L F ( H + \varepsilon _ { 0 } ) ^ { 2 } } { \varepsilon _ { 0 } ^ { 2 } ( \epsilon - \tilde { G } ^ { 2 } / S ) } \Big ) } & { \quad \mathrm { M I M E ~ A d a m ~ } , } \\ { \mathcal { O } \Big ( \frac { L F ( H + \varepsilon _ { 0 } ) ^ { 2 } \sqrt { S } } { \varepsilon _ { 0 } ^ { 2 } ( \epsilon - \tilde { G } ^ { 2 } / S ) } \Big ) } & { \quad \mathrm { M I M E L I T E ~ A d a m ~ } . } \end{array} \right. } \\ & { \bar { \tau } , \tilde { G } ^ { 2 } : = G ^ { 2 } + \sigma ^ { 2 } / K . } \end{array}
+$$
+
+where ${ \cal F } : = f ( x _ { 0 } ) - f ^ { \star } , \tilde { G } ^ { 2 } : \stackrel { \bullet } { = } G ^ { \dot { 2 } } + \stackrel { \bullet } { \sigma } ^ { 2 } / K .$
+
+Note that here $\varepsilon _ { \mathrm { 0 } }$ represents a small positive parameter used in Adam for regularization, and is different from the error $\epsilon$ . Similar to the SERVER-ONLY analysis of Adam [75], we assume $\beta _ { 1 } = 0$
+
+and that batch size is large enough such that $S \ge G ^ { 2 } / \epsilon$ . A similar analysis can also be carried out for AdaGrad, and other novel variants of Adam [42].
+
+# 4.2 Circumventing server-only lower bounds
+
+The rates obtained above, while providing a safety-check, do not beat those of the SERVER-ONLY approach. The previous best rates for cross-device FL correspond to MimeLiteSGD which is $\begin{array} { r } { \ O ( \frac { L G ^ { 2 } } { S \epsilon ^ { 2 } } + \frac { L ^ { 2 } G } { \epsilon ^ { 3 / 2 } } ) } \end{array}$ [34, 36, 69]. While, using a separate server-learning rate can remove the effect of the second term [33], this at best matches the rate of SERVER-ONLY SGD $\mathcal { O } \big ( \textstyle \frac { L G ^ { 2 } } { S \epsilon ^ { 2 } } \big )$ . This is significantly slower than simply using momentum based variance reduction (MVR) as in in the FL setting (SERVER-ONLY MVR) which has a communication complexity of ( √LGS3/2 ) [14]. Thus, even though the main reason for studying local-step methods was to improve the communication complexity, none thus far show such improvement. The above difficulty of beating SERVER-ONLY may not be surprising given the two sets of strong lower bounds known.
+
+Necessity of local steps. Firstly, [5] show a gradient oracle lower bound of $\Omega \big ( \frac { L G } { \sqrt { S } \epsilon ^ { 3 / 2 } } \big )$ This matches the complexity of MVR, and hence at first glance it seems that SERVER-ONLY MVR is optimal. However, the lower bound is really only on the number of gradients computed and not on the number of clients sampled (sample complexity) [18], or number of rounds of communication required. In particular, multiple local updates increases number of gradients computed without needing additional communication offers us a potential way to side-step such lower bounds. A careful analysis of the bias introduced as a result of such local steps is a key part of our analysis.
+
+Necessity of $\delta$ -BHD. A second set of lower bounds directly study the number of communication rounds required in heterogeneous optimization [6, 69]. These results prove that there exist settings where local steps provide no advantage and SERVER-ONLY methods are optimal. This however contradicts real world experimental evidence [43]. As before, the disparity arises due to the contrived settings considered by the lower bounds. For distributed optimization (with full client participation) and convex quadratic objectives, $\delta$ -BHD (A2) was shown to be a sufficient [54, 51] and necessary [6] condition to circumvent these lower bounds and yield highly performant methods. We similarly leverage $\delta$ -BHD (A2) to design novel methods which significantly extend prior results to i) all smooth non-convex functions (not just quadratics), and ii) cross-device FL with client sampling.
+
+We now state our convergence results with momentum based variance reduction (MVR) as the basealgorithm since it is known to be optimal in the SERVER-ONLY setting.
+
+Theorem IV. For $L$ -smooth $f$ with $G ^ { 2 }$ gradient dissimilarity (A1), $\delta$ Hessian dissimilarity (A2) and $F : = ( f ( \pmb { x } ^ { 0 } ) - f ^ { \star } )$ , let us run MVR as the base algorithm for $T$ rounds with $K \ge L / \delta$ local steps and generate an output ${ \pmb x } ^ { o u t }$ . This output satisfies $\bar { \mathbb { E } } \| \nabla f ( \pmb { x } ^ { o u t } ) \| ^ { 2 } \leq \epsilon$ for
+
+• $M i m e M V R$ : $\begin{array} { r } { \eta = \mathcal { O } \Big ( \operatorname* { m i n } \big ( \frac { 1 } { \delta K } , \big ( \frac { S F } { G ^ { 2 } T K ^ { 3 } } \big ) ^ { 1 / 3 } \Big ) \Big ) } \end{array}$ , momentum $\begin{array} { r } { \beta = 1 - \mathcal { O } \big ( \frac { \delta ^ { 2 } S ^ { 2 / 3 } } { ( T G ^ { 2 } ) ^ { 2 / 3 } } \big ) } \end{array}$ ( δ2S2/3(T G2)2/3 ), and
+
+MimeLiteMVR : $\begin{array} { r } { \eta = \mathcal { O } \Big ( \operatorname* { m i n } \big ( \frac { 1 } { \delta K } , \big ( \frac { \mathbf { v } } { \hat { G } ^ { 2 } T K ^ { 3 } } \big ) ^ { 1 / 3 } \Big ) \Big ) } \end{array}$ , momentum $\begin{array} { r } { \beta = 1 - \mathcal { O } ( \frac { \delta ^ { 2 } } { ( T \hat { G } ^ { 2 } ) ^ { 2 / 3 } } ) } \end{array}$
+
+Here, we define ${ \hat { G } } ^ { 2 } : = G ^ { 2 } + \sigma ^ { 2 }$ and the expectation in $\mathbb { E } \| \nabla ^ { \in } f ( \pmb { x } ^ { \mathrm { o u t } } ) \| ^ { 2 } \le \epsilon$ is taken both over the sampling of the clients during the running of the algorithm, the sampling of the mini-batches in local updates, and the choice of $\pmb { x } ^ { \mathrm { o u t } }$ (which is chosen randomly from the client iterates $\mathbf { \nabla } _ { \mathbf { \psi } _ { 3 } } \mathbf { \psi } _ { 2 } \qquad \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \qquad \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \qquad \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 3 } \qquad \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 3 } \qquad \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 3 } \mathbf { \psi } _ { 4 } \mathbf { \psi } _ { 4 }$ ).
+
+Remarkably, the rates of our methods are independent of $L$ and only depend on $\delta$ . Thus, when $\delta \leq L$ and $\bar { \delta } \leq L / _ { S }$ for MimeMVR and MimeLiteMVR, the rates beat the server only lower bound of $\Omega \big ( \frac { L G } { \sqrt { S } \epsilon ^ { 3 / 2 } } \big )$ . In fact, if the Hessian variance is small and $\delta \approx 0$ , our methods only need $\mathcal { O } ( 1 / \epsilon )$ rounds to communicate. Intuitively, our results show that local steps are very useful when heterogeneity (represented by $\delta$ ) is smaller than optimization difficulty (captured by smoothness constant $L$ ).
+
+MimeMVR uses a momentum parameter $\beta$ of the order of $( 1 - \mathcal { O } ( T G ^ { 2 } ) ^ { - 2 / 3 } )$ i.e. as $T$ increases, $\beta$ asymptotically approaches 1. In contrast, previous analyses of distributed momentum (e.g. [73]) prove rates of the form $\frac { G ^ { 2 } } { S ( 1 - \beta ) \epsilon ^ { 2 } }$ , which are worse than that of standard SGD by a factor of $\frac { 1 } { 1 - \beta }$ .
+
+![](images/1ea55dae1f107ef5e01c171ee61180c266dc81e1d9e130ceb449cf46fad9c055.jpg)  
+Figure 1: Mime, MimeLite, FedAvg, Scaffold, FedProx, and Loc-Mime with $\mathrm { S G D + }$ momentum using 10 local epochs, run on EMNIST62 and a 2 hidden layer (300u-100) MLP. (Left) Mime and MimeLite are nearly identical and outperform the rest $7 \times$ faster). (Center) Mime makes better use of momentum than FedAvg, with a large increase in performance. (Right) Locally adapting momentum slows down convergence and makes it more unstable.
+
+Thus, ours is also the first result which theoretically showcases the usefulness of using large momentum in distributed and federated learning. While we only prove the utility of local steps for MimeMVR, we believe our theory can be extended to other local update methods as well.
+
+Our analysis is highly non-trivial and involves two crucial ingredients: i) computing the momentum at the server level to ensure that it remains unbiased and then applying it locally during every client update to reduce variance, and ii) carefully keeping track of the bias introduced via additional local steps. Our experiments (Sec. 5) verify our theoretical insights are indeed applicable in deep learning settings as well. See App. B for a proof sketch and App. G–H detailed proofs.
+
+# 5 Experimental analysis on real world datasets
+
+We run experiments on natively federated datasets to confirm our theory and accurately measure real world performance. Our main findings are i) MIME and MIMELITE consistently outperform FEDAVG, and ii) momentum and adaptivity significantly improves performance.
+
+# 5.1 Setup
+
+Algorithms. We consider three (meta) algorithms: FEDAVG, MIME, and MIMELITE. Each of these adapt four base optimizers: SGD, momentum, Adam, and Adagrad.
+
+FEDAVG follows [49] who run multiple epochs of SGD on each client sampled, and then aggregate the net client updates. This aggregated update is used as a pseudo-gradient in the base optimizer (called server optimizer). The learning rate for the server optimizer is fixed to 1 as in [67]. This is done to ensure all algorithms have the same number of hyper-parameters.
+
+MIME and MIMELITE follow Algorithm 4 and also run a fixed number of epochs on the client. However, note that this requires communicating both the full local-batch gradient as well as the parameter updates doubling the communication required to be sent by the client. For a fairer comparison, we split the sampled clients in MIME and MIMELITE into two groups–the first communicates only full local-batch gradient and the latter communicates only parameter updates. Thus, all methods have equal client communication to the server. This variant retains the convergence guarantees up to constants (details in the Appendix). We also run Loc-MIME where instead of keeping the global optimizer state fixed, we update it locally within the client. The optimizer state is reset after the round finishes. In all methods, aggregation is weighted by the number of samples on the clients.
+
+Datasets and models. We run five simulations on three real-world federated datasets: EMNIST62 with i) a linear classifier, ii) an MLP, and iii) a CNN, iv) a charRNN on Shakespeare, and v) an LSTM for next word prediction on StackOverflow, all accessed through Tensorflow Federated [60]. The learning rates were individually tuned and other optimizer hyper-parameters such as $\beta$ for momentum, $\beta _ { 1 }$ , $\beta _ { 2 }$ , $\varepsilon _ { \mathrm { 0 } }$ for Adam and AdaGrad were left to their default values, unless explicitly stated otherwise. We refer to Appendix C for additional setup details and discussion.
+
+# 5.2 Ablation and comparative study
+
+In order to study the different algorithms, we train a 2 hidden layer ( $3 0 0 \mu$ -100) MLP on EMNIST62 with 10 local epochs for 1k rounds and use SGD $^ +$ momentum (with tuned $\beta$ ) as the base optimizer.
+
+Mime $\approx$ MimeLite $>$ FedAvg $>$ SCAFFOLD $>$ FedProx. Fig. 1 (left) shows MIME and MIMELITE have nearly identical performance, and are about $7 \times$ faster than FedAvg. This implies our strategy of applying momentum to client updates is faster than simply using server momentum. FedProx [40] uses an additional regularizer $\mu$ tuned over [0.1, 0.5, 1] $\mu = 0$ is the same as FedAvg). Regularization does not seem to reduce client drift but still slows down convergence [66]. SCAFFOLD [32] is also slower than Mime and FedAvg in this setup. This is because in cross-device setting with a large number of clients $N = 3 . 4 k )$ ) means that each client is visited less than 6 times during the entire training (20 clients per round for 1k rounds). This means that the correction term utilized by SCAFFOLD uses control-variates which are quite stale (computed about 200 rounds ago) which slows down the convergence. In contrast, the SVRG correction term in Mime is computed using clients sampled in the current or previous rounds, and so is much more accurate.
+
+Table 2: Validation $\%$ accuracies after training for 1000 rounds. Best results for each dataset is underlined and the best within each base optimizer is bolded. The number of clients sampled per round has been reduced for MIME and MIMELITE to ensure all methods have equal client and server communication. Final accuracies obtained by MIME and MIMELITE are competitive with FEDAVG, especially with adaptive base optimizers. FEDAVG seems unstable with Adam.   
+
+<table><tr><td rowspan="3">SGD</td><td colspan="2">EMNIST logistic StackOverflow</td><td colspan="2">EMNIST CNN Shakespeare</td></tr><tr><td>FedAvgSGD</td><td>66.8</td><td>85.8 56.7</td><td>23.8</td></tr><tr><td>MimeLiteSGD</td><td>66.8</td><td>85.8 56.7</td><td>23.8</td></tr><tr><td rowspan="3">MimeSGD MOMENTUM</td><td>67.4</td><td>85.3</td><td>56.1</td><td>12.5</td></tr><tr><td>FedAvgMom</td><td>67.4</td><td>85.7 55.4</td><td>22.2</td></tr><tr><td>MimeLiteMom</td><td>67.4 86.0</td><td>49.8</td><td>19.9</td></tr><tr><td rowspan="3">ADAM</td><td>MimeMom</td><td>67.5</td><td>85.9</td><td>53.6</td><td>19.3</td></tr><tr><td>FedAvgAdam</td><td>67.3</td><td>85.9</td><td>18.5</td><td>3.2</td></tr><tr><td>MimeLiteAdam</td><td>68.0</td><td>86.4</td><td>54.0</td><td>21.5</td></tr><tr><td rowspan="3">ADAGRAD</td><td>MimeAdam</td><td>68.0</td><td>86.6</td><td>54.1</td><td>22.8</td></tr><tr><td>FedAvgAdagrad</td><td>67.6</td><td>86.3</td><td>55.5</td><td>24.2</td></tr><tr><td>MimeLiteAdagrad</td><td>66.6</td><td>85.5</td><td>56.8</td><td>23.8</td></tr><tr><td></td><td>MimeAdagrad</td><td>67.4</td><td>86.3</td><td>57.1</td><td>14.7</td></tr></table>
+
+With momentum $>$ without momentum. Fig. 1 (center) examines the impact of momentum on FedAvg and Mime. Momentum slightly improves the performance of FedAvg, whereas it has a significant impact on the performance of Mime. This is also in line with our theory and confirms that Mime’s strategy of applying it locally at every client update makes better use of momentum.
+
+Fixed $>$ locally updated optimizer state. Finally, we check how the performance of Mime changes if instead of keeping the momentum fixed throughout a round, we let it change. The latter is a way to combine global and local momentum. The momentum is reset at the end of the round ignoring the changes the clients make to it. Fig. 1 (right) shows that this worsens the performance, confirming that it is better to keep the global optimizer state fixed as predicted by our theory.
+
+Together, the above observations validate all aspects of Mime (and MimeLite) design: compute statistics at the server level, and apply them unchanged at every client update.
+
+# 5.3 Large scale comparison with equal server and client communication
+
+We perform a larger scale study closely matching the setup of [49]. For both MIME and MIMELITE, only half the clients compute and transmit the updated parameters, and other half transmit the full local-batch gradients. Hence, client to server communication cost is the same for all methods for all clients. However, MIME and MIMELITE require sending additional optimization state to the clients. Hence, we also reduce the number of clients sampled in each round to ensure sum total of communication at each round is $4 0 \times$ model size for EMNIST and Shakespeare experiments, and $1 0 0 \times$ model size for the StackOverflow next word prediction experiment.
+
+Since we only perform 1 local epoch, the hyper-parameters (e.g. epsilon for adaptive methods) are more carefully chosen following [49], and MIME and MIMELITE use significantly fewer clients per round, the difference between FEDAVG and MIME is smaller here. Table 2 summarizes the results.
+
+For the image classification tasks of EMNIST62 logistic and EMNIST62 CNN, Mime and MimeLite with Adam achieve the best performance. Using momentum (both with SGD and in Adam) significantly improves their performance. In contrast, FedAvgAdam is more unstable with worse performance. This is because FedAvg is excessively sensitive to hyperparameters (cf. App. E).
+
+We next consider the character prediction task on Shakespeare dataset, and next word prediction on StackOverflow. Here, the momentum based methods (SGD $^ +$ momentum and Adam) are slower than their non-momentum counterparts (vanilla SGD and AdaGrad). This is because the mini-batch gradients in these tasks are sparse, with the gradients corresponding to tokens not in the mini-batch being zero. This sparsity structure is however destroyed when using momentum or Adam. For the same reason, Mime which uses an SVRG correction also significantly increases the gradient density.
+
+Discussion. For traditional tasks such as image classification, we observe that Mime (especially with Adam) usually outperforms MimeLite which in turn outperforms FedAvg. These methods are able to successfully leverage momentum and adaptivity to improve performance. For tasks where the client gradients are sparse, the SVRG correction used by Mime hinders performance. Adapting our techniques to work with sparse gradients (a la Yogi [ \` 75]) could lead to further improvements. Also, note that we reduce communication by na¨ıvely reducing the number of participating clients per round. More sophisticated approaches to save on client communication including quantization or sparsification [58, 3], or even novel algorithmic innovations [1] could be explored. Further, server communication could be reduced using memory efficient optimizers e.g. AdaFactor [55] or SM3 [4].
+
+# 6 Conclusion
+
+Our work initiated a formal study of the cross-device federated learning problem and provided theoretically justified algorithms. We introduced a new framework MIME which overcomes the natural client-heterogeneity in such a setting, and can adapt arbitrary centralized algorithms such as Adam without additional hyper-parameters. We demonstrated the superiority of MIME via strong convergence guarantees and empirical evaluations. Further, we proved that a particular instance of our method, MimeMVR, beat centralized lower-bounds, demonstrating that additional local steps can yield asymptotic improvements for the first time. We believe our analysis will be of independent interest beyond the federated setting for understanding the sample complexity of non-convex optimization, and for yielding improved analysis of decentralized optimization algorithms.
+
+# References
+
+[1] Durmus Alp Emre Acar, Yue Zhao, Ramon Matas Navarro, Matthew Mattina, Paul N Whatmough, and Venkatesh Saligrama. Federated learning based on dynamic regularization. In International Conference on Learning Representations, 2021.   
+[2] Naman Agarwal, Ananda Theertha Suresh, Felix X. Yu, Sanjiv Kumar, and Brendan McMahan. cpSGD: Communication-efficient and differentially-private distributed SGD. In Proceedings of NeurIPS, pages 7575–7586, 2018.   
+[3] Dan Alistarh, Demjan Grubic, Jerry Li, Ryota Tomioka, and Milan Vojnovic. Qsgd: Communication-efficient sgd via gradient quantization and encoding. In Advances in Neural Information Processing Systems (NeurIPS), 2017.   
+[4] Rohan Anil, Vineet Gupta, Tomer Koren, and Yoram Singer. Memory-efficient adaptive optimization. arXiv preprint arXiv:1901.11150, 2019.   
+[5] Yossi Arjevani, Yair Carmon, John C Duchi, Dylan J Foster, Nathan Srebro, and Blake Woodworth. Lower bounds for non-convex stochastic optimization. arXiv preprint arXiv:1912.02365, 2019.   
+[6] Yossi Arjevani and Ohad Shamir. Communication complexity of distributed convex learning and optimization. In Advances in neural information processing systems, pages 1756–1764, 2015.   
+[7] Keith Bonawitz, Hubert Eichner, Wolfgang Grieskamp, Dzmitry Huba, Alex Ingerman, Vladimir Ivanov, Chloe Kiddon, Jakub Konecnˇ y, Stefano Mazzocchi, H Brendan McMahan, \` et al. Towards federated learning at scale: System design. arXiv preprint arXiv:1902.01046, 2019.   
+[8] Keith Bonawitz, Vladimir Ivanov, Ben Kreuter, Antonio Marcedone, H. Brendan McMahan, Sarvar Patel, Daniel Ramage, Aaron Segal, and Karn Seth. Practical secure aggregation for privacy-preserving machine learning. In Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security, pages 1175–1191. ACM, 2017.   
+[9] Sebastian Caldas, Jakub Konecny, H Brendan McMahan, and Ameet Talwalkar. Expand- ˇ ing the reach of federated learning by reducing client resource requirements. arXiv preprint arXiv:1812.07210, 2018.   
+[10] Sebastian Caldas, Peter Wu, Tian Li, Jakub Konecnˇ y, H Brendan McMahan, Virginia \` Smith, and Ameet Talwalkar. Leaf: A benchmark for federated settings. arXiv preprint arXiv:1812.01097, 2018.   
+[11] Zachary Charles and Jakub Konecnˇ y. On the outsized importance of learning rates in local \` update methods. arXiv preprint arXiv:2007.00878, 2020.   
+[12] Gregory Cohen, Saeed Afshar, Jonathan Tapson, and Andre Van Schaik. Emnist: Extending mnist to handwritten letters. In 2017 International Joint Conference on Neural Networks (IJCNN), pages 2921–2926. IEEE, 2017.   
+[13] Ashok Cutkosky and Harsh Mehta. Momentum improves normalized SGD. arXiv preprint arXiv:2002.03305, 2020.   
+[14] Ashok Cutkosky and Francesco Orabona. Momentum-based variance reduction in non-convex SGD. In Advances in Neural Information Processing Systems, pages 15210–15219, 2019.   
+[15] Aaron Defazio and Leon Bottou. On the ineffectiveness of variance reduced optimization ´ for deep learning. In Advances in Neural Information Processing Systems, pages 1753–1763, 2019.   
+[16] Stack Exchange. Stack exchange data dump. https: // archive. org/ details/ stackexchange , 2021.   
+[17] Cong Fang, Chris Junchi Li, Zhouchen Lin, and Tong Zhang. SPIDER: Near-optimal nonconvex optimization via stochastic path-integrated differential estimator. In Advances in Neural Information Processing Systems, pages 689–699, 2018.   
+[18] Dylan J Foster, Ayush Sekhari, Ohad Shamir, Nathan Srebro, Karthik Sridharan, and Blake Woodworth. The complexity of making the gradient small in stochastic convex optimization. In Conference on Learning Theory, pages 1319–1345. PMLR, 2019.   
+[19] Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. International Conference on Learning Representations (ICLR), 2019.   
+[20] Robin C Geyer, Tassilo Klein, and Moin Nabi. Differentially private federated learning: A client level perspective. arXiv preprint arXiv:1712.07557, 2017.   
+[21] Saeed Ghadimi and Guanghui Lan. Stochastic first-and zeroth-order methods for nonconvex stochastic programming. SIAM Journal on Optimization, 23(4):2341–2368, 2013.   
+[22] Jenny Hamer, Mehryar Mohri, and Ananda Theertha Suresh. FedBoost: Communicationefficient algorithms for federated learning. In 37th International Conference on Machine Learning (ICML), 2020.   
+[23] Andrew Hard, Kurt Partridge, Cameron Nguyen, Niranjan Subrahmanya, Aishanee Shah, Pai Zhu, Ignacio Lopez Moreno, and Rajiv Mathews. Training keyword spotting models on non-iid data with federated learning. arXiv preprint arXiv:2005.10406, 2020.   
+[24] Lie He, Sai Praneeth Karimireddy, and Martin Jaggi. Secure byzantine-robust machine learning. arXiv preprint arXiv:2006.04747, 2020.   
+[25] Arne Holst. Smartphone users worldwide 2016-2021. Statista https: // web. archive. org/ web/ 20210608080335/ https: // www. statista. com/ statistics/ 330695/ number-of-smartphone-users-worldwide/ , 2019.   
+[26] Tzu-Ming Harry Hsu, Hang Qi, and Matthew Brown. Measuring the effects of non-identical data distribution for federated visual classification. arXiv preprint arXiv:1909.06335, 2019.   
+[27] Rie Johnson and Tong Zhang. Accelerating stochastic gradient descent using predictive variance reduction. In Advances in neural information processing systems, pages 315–323, 2013.   
+[28] Peter Kairouz, H Brendan McMahan, Brendan Avent, Aurelien Bellet, Mehdi Bennis, Ar- ´ jun Nitin Bhagoji, Keith Bonawitz, Zachary Charles, Graham Cormode, Rachel Cummings, et al. Advances and open problems in federated learning. arXiv preprint arXiv:1912.04977, 2019.   
+[29] Hamed Karimi, Julie Nutini, and Mark Schmidt. Linear convergence of gradient and proximalgradient methods under the polyak-łojasiewicz condition. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pages 795–811. Springer, 2016.   
+[30] Sai Praneeth Karimireddy, Lie He, and Martin Jaggi. Learning from history for byzantine robust optimization. In 38th International Conference on Machine Learning (ICML), 2021.   
+[31] Sai Praneeth Karimireddy, Martin Jaggi, Satyen Kale, Mehryar Mohri, Sashank J Reddi, Sebastian U Stich, and Ananda Theertha Suresh. Mime: Mimicking centralized stochastic algorithms in federated learning. arXiv preprint arXiv:2008.03606, 2020.   
+[32] Sai Praneeth Karimireddy, Satyen Kale, Mehryar Mohri, Sashank J Reddi, Sebastian U Stich, and Ananda Theertha Suresh. SCAFFOLD: Stochastic controlled averaging for on-device federated learning. In 37th International Conference on Machine Learning (ICML), 2020.   
+[33] Sai Praneeth Karimireddy, Quentin Rebjock, Sebastian U. Stich, and Martin Jaggi. Error feedback fixes SignSGD and other gradient compression schemes. In 36th International Conference on Machine Learning (ICML), 2019.   
+[34] Ahmed Khaled, Konstantin Mishchenko, and Peter Richtarik. Tighter theory for local SGD on ´ indentical and heterogeneous data. In Proceedings of AISTATS, 2020.   
+[35] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+[36] Anastasia Koloskova, Nicolas Loizou, Sadra Boreiri, Martin Jaggi, and Sebastian U Stich. A unified theory of decentralized SGD with changing topology and local updates. In $3 7 t h$ International Conference on Machine Learning (ICML), 2020.   
+[37] Jakub Konecnˇ y, H. Brendan McMahan, Daniel Ramage, and Peter Richt \` arik. Feder- ´ ated optimization: Distributed machine learning for on-device intelligence. arXiv preprint arXiv:1610.02527, 2016.   
+[38] Jakub Konecnˇ y, H. Brendan McMahan, Felix X. Yu, Peter Richt \` arik, Ananda Theertha Suresh, ´ and Dave Bacon. Federated learning: Strategies for improving communication efficiency. arXiv preprint arXiv:1610.05492, 2016.   
+[39] Lihua Lei and Michael Jordan. Less than a single pass: Stochastically controlled stochastic gradient. In AISTATS, pages 148–156, 2017.   
+[40] Tian Li, Anit Kumar Sahu, Maziar Sanjabi, Manzil Zaheer, Ameet Talwalkar, and Virginia Smith. On the convergence of federated optimization in heterogeneous networks. arXiv preprint arXiv:1812.06127, 2018.   
+[41] Tian Li, Maziar Sanjabi, and Virginia Smith. Fair resource allocation in federated learning. arXiv preprint arXiv:1905.10497, 2019.   
+[42] Liyuan Liu, Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Jiawei Han. On the variance of the adaptive learning rate and beyond. arXiv preprint arXiv:1908.03265, 2019.   
+[43] Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. ¨ Communication-efficient learning of deep networks from decentralized data. In Proceedings of AISTATS, pages 1273–1282, 2017.   
+[44] Mehryar Mohri, Gary Sivek, and Ananda Theertha Suresh. Agnostic federated learning. arXiv preprint arXiv:1902.00146, 2019.   
+[45] Yurii Nesterov. Lectures on convex optimization, volume 137. Springer, 2018.   
+[46] Lam M. Nguyen, Jie Liu, Katya Scheinberg, and Martin Taka´c. Stochastic recursive gradient ˇ algorithm for nonconvex optimization. arXiv preprint arXiv:1705.07261, 2017.   
+[47] Kumar Kshitij Patel and Aymeric Dieuleveut. Communication trade-offs for synchronized distributed SGD with large step size. In 33rd Conference on Neural Information Processing Systems (NeurIPS), 2019.   
+[48] Krishna Pillutla, Sham M Kakade, and Zaid Harchaoui. Robust aggregation for federated learning. arXiv preprint arXiv:1912.13445, 2019.   
+[49] Sashank Reddi, Zachary Charles, Manzil Zaheer, Zachary Garrett, Keith Rush, Jakub Konecnˇ y,\` Sanjiv Kumar, and H Brendan McMahan. Adaptive federated optimization. arXiv preprint arXiv:2003.00295, 2020.   
+[50] Sashank J Reddi, Satyen Kale, and Sanjiv Kumar. On the convergence of adam and beyond. International Conference on Learning Representations (ICLR), 2018.   
+[51] Sashank J. Reddi, Jakub Konecnˇ y, Peter Richt \` arik, Barnab ´ as P ´ ocz ´ os, and Alex Smola. Aide: ´ Fast and communication efficient distributed optimization. arXiv preprint arXiv:1608.06879, 2016.   
+[52] Jae Hun Ro, Ananda Theertha Suresh, and Ke Wu. FedJAX: Federated learning simulation with JAX, 2020.   
+[53] Jae Hun Ro, Ananda Theertha Suresh, and Ke Wu. Fedjax: Federated learning simulation with jax. arXiv preprint arXiv:2108.02117, 2021.   
+[54] Ohad Shamir, Nati Srebro, and Tong Zhang. Communication-efficient distributed optimization using an approximate newton-type method. In International conference on machine learning, pages 1000–1008, 2014.   
+[55] Noam Shazeer and Mitchell Stern. Adafactor: Adaptive learning rates with sublinear memory cost. In International Conference on Machine Learning, pages 4596–4604. PMLR, 2018.   
+[56] Sebastian U. Stich. Local SGD converges fast and communicates little. International Conference on Learning Representations (ICLR), 2019.   
+[57] Sebastian U. Stich and Sai Praneeth Karimireddy. The error-feedback framework: Better rates for SGD with delayed gradients and compressed communication. arXiv preprint arXiv:1909.05350, 2019.   
+[58] Ananda Theertha Suresh, Felix X. Yu, Sanjiv Kumar, and H. Brendan McMahan. Distributed mean estimation with limited communication. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 3329–3337. JMLR. org, 2017.   
+[59] Ilya Sutskever, James Martens, George Dahl, and Geoffrey Hinton. On the importance of initialization and momentum in deep learning. In International conference on machine learning, pages 1139–1147, 2013.   
+[60] TFF. Tensorflow federated datasets. https: // www. tensorflow. org/ federated/ api_ docs/ python/ tff/ simulation/ datasets , 2020.   
+[61] Om Thakkar, Swaroop Ramaswamy, Rajiv Mathews, and Franc¸oise Beaufays. Understanding unintended memorization in federated learning. arXiv preprint arXiv:2006.07490, 2020.   
+[62] Quoc Tran-Dinh, Nhan H. Pham, Dzung T. Phan, and Lam M. Nguyen. Hybrid stochastic gradient descent algorithms for stochastic nonconvex optimization. arXiv preprint arXiv:1905.05920, 2019.   
+[63] Sharan Vaswani, Francis Bach, and Mark Schmidt. Fast and faster convergence of SGD for over-parameterized models and an accelerated perceptron. arXiv preprint arXiv:1810.07288, 2018.   
+[64] Thijs Vogels, Sai Praneeth Karimireddy, and Martin Jaggi. Powersgd: Practical low-rank gradient compression for distributed optimization. In Advances in Neural Information Processing Systems (NeurIPS), 2019.   
+[65] Hongyi Wang, Kartik Sreenivasan, Shashank Rajput, Harit Vishwakarma, Saurabh Agarwal, Jy-yong Sohn, Kangwook Lee, and Dimitris Papailiopoulos. Attack of the tails: Yes, you really can backdoor federated learning. arXiv preprint arXiv:2007.05084, 2020.   
+[66] Jianyu Wang, Qinghua Liu, Hao Liang, Gauri Joshi, and H Vincent Poor. Tackling the objective inconsistency problem in heterogeneous federated optimization. arXiv preprint arXiv:2007.07481, 2020.   
+[67] Jianyu Wang, Vinayak Tantia, Nicolas Ballas, and Michael Rabbat. SlowMo: Improving communication-efficient distributed sgd with slow momentum. International Conference on Learning Representations (ICLR), 2020.   
+[68] Shiqiang Wang, Tiffany Tuor, Theodoros Salonidis, Kin K. Leung, Christian Makaya, Ting He, and Kevin Chan. Adaptive federated learning in resource constrained edge computing systems. IEEE Journal on Selected Areas in Communications, 37(6):1205–1221, 2019.   
+[69] Blake Woodworth, Kumar Kshitij Patel, and Nathan Srebro. Minibatch vs local SGD for heterogeneous distributed learning. arXiv preprint arXiv:2006.04735, 2020.   
+[70] Blake Woodworth, Kumar Kshitij Patel, Sebastian U Stich, Zhen Dai, Brian Bullins, H Brendan McMahan, Ohad Shamir, and Nathan Srebro. Is local SGD better than minibatch SGD? In 37th International Conference on Machine Learning (ICML), 2020.   
+[71] Yang You, Igor Gitman, and Boris Ginsburg. Large batch training of convolutional networks. arXiv preprint arXiv:1708.03888, 2017.   
+[72] Yang You, Jing Li, Sashank Reddi, Jonathan Hseu, Sanjiv Kumar, Srinadh Bhojanapalli, Xiaodan Song, James Demmel, Kurt Keutzer, and Cho-Jui Hsieh. Large batch optimization for deep learning: Training bert in 76 minutes. In International Conference on Learning Representations, 2019.   
+[73] Hao Yu, Rong Jin, and Sen Yang. On the linear speedup analysis of communication efficient momentum sgd for distributed non-convex optimization. arXiv preprint arXiv:1905.03817, 2019.   
+[74] Hao Yu, Sen Yang, and Shenghuo Zhu. Parallel restarted SGD with faster convergence and less communication: Demystifying why model averaging works for deep learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 5693–5700, 2019.   
+[75] Manzil Zaheer, Sashank Reddi, Devendra Sachan, Satyen Kale, and Sanjiv Kumar. Adaptive methods for nonconvex optimization. In Advances in neural information processing systems, pages 9793–9803, 2018.   
+[76] Jingzhao Zhang, Tianxing He, Suvrit Sra, and Ali Jadbabaie. Why gradient clipping accelerates training: A theoretical justification for adaptivity. In International Conference on Learning Representations, 2020.   
+[77] Jingzhao Zhang, Sai Praneeth Karimireddy, Andreas Veit, Seungyeon Kim, Sashank J Reddi, Sanjiv Kumar, and Suvrit Sra. Why ADAM beats SGD for attention models. arXiv preprint arXiv:1912.03194, 2019.   
+[78] Martin Zinkevich, Markus Weimer, Lihong Li, and Alex J Smola. Parallelized stochastic gradient descent. In Advances in neural information processing systems, pages 2595–2603, 2010.

parse/train/FMPuzXV1fR/FMPuzXV1fR_content_list.json

@@ -0,0 +1,1347 @@
+[
+    {
+        "type": "text",
+        "text": "Breaking the centralized barrier for cross-device federated learning∗ ",
+        "text_level": 1,
+        "bbox": [
+            205,
+            122,
+            792,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sai Praneeth Karimireddy EPFL sai.karimireddy@epfl.ch ",
+        "bbox": [
+            196,
+            226,
+            392,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Martin Jaggi EPFL martin.jaggi@epfl.ch ",
+        "bbox": [
+            418,
+            226,
+            593,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Satyen Kale Google Research satyenkale@google.com ",
+        "bbox": [
+            620,
+            226,
+            803,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mehryar Mohri Google Research mohri@google.com ",
+        "bbox": [
+            207,
+            289,
+            349,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sashank J. Reddi Google Research sashank@google.com ",
+        "bbox": [
+            390,
+            289,
+            549,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sebastian U. Stich EPFL sebastian.stich@epfl.ch ",
+        "bbox": [
+            589,
+            289,
+            789,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ananda Theertha Suresh Google Research theertha@google.com ",
+        "bbox": [
+            411,
+            352,
+            586,
+            393
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            430,
+            535,
+            445
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Federated learning (FL) is a challenging setting for optimization due to the heterogeneity of the data across different clients which can cause a client drift phenomenon. In fact, designing an algorithm for FL that is uniformly better than simple centralized training has been a major open problem thus far. In this work, we propose a general algorithmic framework, MIME, which i) mitigates client drift and ii) adapts an arbitrary centralized optimization algorithm such as momentum and Adam to the cross-device federated learning setting. MIME uses a combination of control-variates and server-level optimizer state (e.g. momentum) at every client-update step to ensure that each local update mimics that of the centralized method run on i.i.d. data. We prove a reduction result showing that MIME can translate the convergence of a generic algorithm in the centralized setting into convergence in the federated setting. Moreover, we show that, when combined with momentum-based variance reduction, MIME is provably faster than any centralized method–the first such result. We also perform a thorough experimental exploration of MIME’s performance on real world datasets (implemented here). ",
+        "bbox": [
+            233,
+            460,
+            764,
+            667
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            691,
+            310,
+            708
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Federated learning (FL) is an increasingly important large-scale learning framework where the training data remains distributed over a large number of clients, which may be mobile phones or network sensors [38, 37, 43, 44, 28]. A server then orchestrates the clients to train a single model, here referred to as a server model, without ever transmitting client data over the network, thereby providing some basic levels of data privacy and security. ",
+        "bbox": [
+            174,
+            722,
+            823,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Two important settings are distinguished in FL [28, Table 1]: the cross-device and the cross-silo settings. The cross-silo setting corresponds to a relatively small number of reliable clients, typically organizations, such as medical or financial institutions. In contrast, in the cross-device federated learning setting, the number of clients may be extremely large and include, for example, all 3.5 billion active android phones [25]. Thus, in that setting, we may never make even a single pass over the entire clients’ data during training. The cross-device setting is further characterized by resourcepoor clients communicating over a highly unreliable network. Together, the essential features of this setting give rise to unique challenges not present in the cross-silo setting. In this work, we are interested in the more challenging cross-device setting, for which we will formalize and study stochastic optimization algorithms. Importantly, recent advances in FL optimization, such as SCAFFOLD [32] or FedDyn [1], are not anymore applicable since they are designed for the cross-silo setting. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            867
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The problem. The de facto standard algorithm for the cross-device setting is FEDAVG [43], which performs multiple SGD updates on the available clients before communicating to the server. While this approach can reduce the frequency of communication required, performing multiple steps on the same client can lead to ‘over-fitting’ to its atypical local data, a phenomenon known as client drift [32]. This in turn leads to slower convergence and can, somewhat counter-intuitively, require larger total communication [69]. Despite significant attention received from the optimization community, the communication complexity of heterogeneous cross-device has not improved upon that of simple centralized methods, which take no local steps (aka SERVER-ONLY methods). Furthermore, algorithmic innovations such as momentum [59, 14], adaptivity [35, 75, 77], and clipping [71, 72, 76] are critical to the success of deep learning applications. The lack of a theoretical understanding of the impact of multiple client steps has also hindered adapting these techniques in a principled manner into the client updates, in order to replace the vanilla SGD update of FEDAVG. ",
+        "bbox": [
+            174,
+            195,
+            825,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To overcome such deficiencies, we propose a new framework, MIME, that mitigates client drift and can adapt an arbitrary centralized optimization algorithm, e.g. SGD with momentum or Adam, to the federated setting. In each local client update, MIME uses global optimizer state, e.g. momentum or adaptive learning rates, and an SVRG-style correction to mimic the updates of the centralized algorithm run on i.i.d. data. This optimizer state is computed only at the server level and kept fixed throughout the local steps, thereby avoiding overfitting to the atypical local data of any single client. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            452
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions. We summarize our main results below. ",
+        "bbox": [
+            174,
+            465,
+            545,
+            479
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• MIME framework. We formalize the cross-device federated learning problem, and propose a new framework MIME that can adapt arbitrary centralized algorithms to this setting. • Convergence result. We prove a result showing that MIME successfully reduces client drift. We also prove that the convergence of any generic algorithm in the centralized setting translates convergence of its MIME version in the federated setting. • Speed-up over centralized methods. By carefully tracking the bias introduced due to multiple local steps, we prove that MIME with momentum-based variance reduction (MVR) can beat a lower bound for centralized methods, thus breaking a fundamental barrier. This is the first such result in FL, and also the first general result showing asymptotic speed-up due to local steps. • Empirical validation. We propose a simpler variant, MIMELITE, with an empirical performance similar to MIME. We report the results of thorough experimental analysis demonstrating that both MIME and MIMELITE indeed converge faster than FEDAVG. ",
+        "bbox": [
+            183,
+            483,
+            826,
+            648
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Related work. Analysis of FEDAVG: Much of the recent work in federated learning has focused on analyzing FEDAVG. For identical clients, FEDAVG coincides with parallel SGD, for which [78] derived an analysis with asymptotic convergence. Sharper and more refined analyses of the same method, sometimes called local SGD, were provided by [56], and more recently by [57], [47], [34], and [70], for identical functions. Their analysis was extended to heterogeneous clients in [68, 74, 32, 34, 36]. [11] derived a tight characterization of FedAvg with quadratic functions and demonstrated the sensitivity of the algorithm to both client and server step sizes. Matching upper and lower bounds were recently given by [32] and [69] for general functions, proving that FEDAVG can be slower than even SGD for heterogeneous data, due to the client-drift. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            794
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Comparison to SCAFFOLD: For the cross-silo setting where the number of clients is relatively low, [32] proposed the SCAFFOLD algorithm, which uses control-variates (similar to SVRG) to correct for client drift. However, their algorithm crucially relies on stateful clients which repeatedly participate in the training process. FedDyn [1] reduces the communication requirements, but also requires persistent stateful clients. In contrast, we focus on the cross-device setting where clients may be visited only once during training and where they are stateless (and thus SCAFFOLD and FedDyn are inapplicable). This is akin to the difference between the finite-sum (corresponding to cross-silo) and stochastic (cross-device) settings in traditional centralized optimization [39]. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Comparison to FedAvg and variants: [26] and [67] observed that using server momentum significantly improves over vanilla FEDAVG. This idea was generalized by [49], who replaced the server update with an arbitrary optimizer, e.g. Adam. However, these methods only modify the server update while using SGD for the client updates. We henceforth refer to this meta algorithm as FedAvg. FedAvgSGD, FedAvgMom, FedAvgAdam denote specific instantiations of the server optimizer in FedAvg with SGD, Momentum or Adam. MIME, on the other hand, ensures that every local client update resembles the optimizer e.g. MIME would apply momentum in every client update and not just at the server level. Beyond this, [40] proposed to add a regularizer to ensure client updates remain close. However, this may slow down convergence (cf. Fig. 5 and [32, 66]). Other orthogonal directions which can be combined with MIME include tackling computation heterogeneity, where some clients perform many more updates than others [66], improving fairness by modifying the objective [44, 41], incorporating differential privacy [20, 2, 61], Byzantine adversaries [48, 65, 30], secure aggregation [8, 24], etc. We defer additional discussion to the extensive survey by [28]. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            270
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Momentum based variance reduction. Initial optimal methods for stochastic non-convex optimization like SPIDER [17] and SARAH [46] required intermittently computing very large batch gradients. Subsequently, it was shown that momentum based variance reduction (MVR) methods obtained a similar optimal rate without needing such large batch gradient computations [62, 14]. Momentum is an exponential moving average of many stochastic gradients and so it has much smaller variance than the stochastic gradients themselves. However, because these gradients are computed at different parameters it also has a bias. MVR adds a small additional correction term which significantly reduces this bias and provides improved rates. ",
+        "bbox": [
+            173,
+            276,
+            825,
+            388
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Problem setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            411,
+            326,
+            429
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This section formalizes the problem of cross-device federated learning [28]. Cross-device FL is characterized by a large number of client devices like mobile phones which may potentially connect to the server at most once. Due to their transient nature, it is not possible to store any state on the clients, precluding an algorithm like SCAFFOLD. Furthermore, each client has only a few samples, and there is wide heterogeneity in the samples across clients. Finally, communication is a major bottleneck and a key metric for optimization in this setting is the number of communication rounds. ",
+        "bbox": [
+            173,
+            444,
+            825,
+            529
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Thus, our objective will be to minimize the following quantity within the fewest number of clientserver communication rounds: ",
+        "bbox": [
+            173,
+            534,
+            823,
+            563
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6a499d31b6f747711060282e8c4c862167e695ef417fff87399f6808b81a46d2.jpg",
+        "text": "$$\nf ( \\pmb { x } ) = \\mathbb { E } _ { i \\sim \\mathcal { C } } \\Big [ f _ { i } ( \\pmb { x } ) : = \\frac { 1 } { n _ { i } } \\sum _ { \\nu = 1 } ^ { n _ { i } } f _ { i } ( \\pmb { x } ; \\zeta _ { i , \\nu } ) \\Big ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            560,
+            647,
+            602
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $f _ { i }$ denotes the loss function of client $i$ and $\\{ \\zeta _ { i , 1 } , \\ldots , \\zeta _ { i , n _ { i } } \\}$ its local data. Since the number of clients is extremely large, while the size of each local data is rather modest, we represent the former as an expectation and the latter as a finite sum. In each round, the algorithm samples a subset of clients (of size $S$ ) and performs some updates to the server model. Due to the transient and heterogeneous nature of the clients, it is easy to see that the problem becomes intractable with arbitrarily dissimilar clients. Thus, it is necessary to assume bounded dissimilarity across clients. ",
+        "bbox": [
+            173,
+            611,
+            825,
+            695
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(A1) $G ^ { 2 }$ -BGV or bounded inter-client gradient variance: there exists $G \\geq 0$ such that ",
+        "bbox": [
+            174,
+            700,
+            741,
+            715
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d1ee2c9984fab3ca7e16a795ae54e193fecc5f713bb66f375a14345078e0d5b7.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } _ { i \\sim \\mathcal { C } } [ \\| \\nabla f _ { i } ( \\pmb { x } ) - \\nabla f ( \\pmb { x } ) \\| ^ { 2 } ] \\le G ^ { 2 } , \\forall \\pmb { x } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            724,
+            655,
+            743
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Next, we also characterize the variance in the Hessians. ",
+        "bbox": [
+            178,
+            753,
+            534,
+            768
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(A2) $\\delta$ -BHV or bounded Hessian variance: Almost surely, the loss function of any client $i$ satisfies ",
+        "bbox": [
+            176,
+            775,
+            823,
+            790
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ab00894b0c6d803e2c9b68b7e35e2d6991474004bea629c6b080e46f73ca233e.jpg",
+        "text": "$$\n\\begin{array} { r } { \\| \\nabla ^ { 2 } f _ { i } ( { \\pmb x } ; \\zeta ) - \\nabla ^ { 2 } f ( { \\pmb x } ) \\| \\leq \\delta , \\forall { \\pmb x } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            805,
+            640,
+            824
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This is in contrast to the usual smoothness assumption that can be stated as: ",
+        "bbox": [
+            174,
+            828,
+            669,
+            843
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$( \\mathbf { A } 2 ^ { * } )$ ) $L$ -smooth: $\\| \\nabla ^ { 2 } f _ { i } ( \\pmb { x } ; \\zeta ) \\| \\le L$ , $\\forall x$ , a.s. for any $i$ . ",
+        "bbox": [
+            174,
+            848,
+            558,
+            864
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that if $f _ { i } ( x ; \\zeta )$ is $L$ -smooth then (A2) is satisfied with $\\delta \\leq 2 L$ , and hence (A2) is weaker than $( \\mathsf { A } 2 ^ { \\ast } )$ . In realistic examples we expect the clients to be similar and hence that $\\delta \\ll L$ . In addition, we assume that $f ( { \\pmb x } )$ is bounded from below by $f ^ { \\star }$ and is $L$ -smooth, as is standard. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Mime framework ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            352,
+            106
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section we describe how to adapt an arbitrary centralized optimizer (referred to as the “base” optimizer) which may have internal state (e.g. momentum) to the federated learning problem (1) while ensuring there is no client-drift. Algorithm 4 describes our framework. We develop two variants, MIME and MIMELITE, which consist of three components i) a base optimizer we are seeking to mimic, ii) the global (server) optimizer state computation, and iii) the local client updates. ",
+        "bbox": [
+            173,
+            119,
+            825,
+            190
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Mime and MimeLite ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            209,
+            423,
+            228
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/95ad07342c08bd97753fd880f625d8e48c6e1dc5700960b69aa00ec846ba4427.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>input: initial x and s,learning rate η and base optimize B= (U,V) for each round t = 1,..,T do sample subset S of clients</td></tr><tr><td>communicate (x, s) to all clients i ∈ S communicate c ←  ∑j∈s Vf(x) (only Mime)</td></tr><tr><td>on client i ∈ S in parallel do initialize local model yi ←x for k=1,.,K do</td></tr><tr><td>sample mini-batch ‘ from local data gi ← Vfi(yi;S)-Vfi(x;S)+c (Mime)</td></tr><tr><td>gi ←Vfi(yi; S) (MimeLite)</td></tr><tr><td>update yi ← yi - nu(gi,s) end for</td></tr><tr><td>compute full local-batch gradient Vfi(x) communicate (yi, Vf (x))</td></tr><tr><td>end on client</td></tr><tr><td>8 ← V(ΣiesVfi(x),s) (update optimize state)</td></tr><tr><td>x ← ∑i∈s yi (update server parameters) end for</td></tr></table>",
+        "bbox": [
+            171,
+            229,
+            560,
+            559
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Base optimizer. We assume the centralized base optimizer we are imitating can be decomposed into two steps: an update step $\\mathcal { U }$ which updates the parameters $_ { \\textbf { \\em x } }$ , and a optimizer state update step $\\mathcal { V } ( \\cdot )$ which keeps track of global optimizer state $\\pmb { s }$ . Each step of the base optimizer $\\boldsymbol { B } = ( \\boldsymbol { \\mathcal { U } } , \\boldsymbol { \\mathcal { V } } )$ uses a gradient $\\textbf {  { g } }$ to update the parameter $_ { \\textbf { \\em x } }$ and the optimizer state $\\pmb { s }$ as follows: ",
+        "bbox": [
+            575,
+            205,
+            823,
+            356
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/30dc42112fd4733b9d97aa65498396a2084ec0f37401c4b1eeec188a18c7a85c.jpg",
+        "text": "$$\n\\begin{array} { l } { { { \\pmb x }  { \\pmb x } - \\eta \\mathcal { U } ( { \\pmb g } , { \\pmb s } ) , } } \\\\ { { { \\pmb s }  \\mathcal { V } ( { \\pmb g } , { \\pmb s } ) . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            588,
+            358,
+            730,
+            396
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As an example, consider SGD with momentum. The state here is the momentum ${ \\mathbf { } } m _ { t }$ and uses the following update steps: ",
+        "bbox": [
+            575,
+            398,
+            823,
+            454
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/219f80f4b9e2f853bac51b4dfd6106ace88a05082426f7ccd4ac8314be17ee89.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\pmb { x } _ { t } = \\pmb { x } _ { t - 1 } - \\eta \\left( ( 1 - \\beta ) \\nabla f _ { i } ( \\pmb { x } _ { t - 1 } ) \\right. } \\\\ & { \\qquad \\quad + \\left. \\beta \\pmb { m } _ { t - 1 } \\right) , } \\\\ & { \\pmb { m } _ { t } = ( 1 - \\beta ) \\nabla f _ { i } ( \\pmb { x } _ { t - 1 } ) + \\beta \\pmb { m } _ { t - 1 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            576,
+            458,
+            823,
+            513
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Thus, SGD with momentum can be represented in the above generic form with $\\mathcal { U } ( { \\pmb g } , { \\pmb s } ) = ( 1 - \\beta ) { \\overset { } { \\pmb g } } + \\beta { \\pmb s }$ and $\\mathcal { V } ( { \\pmb g } , \\pmb s ) = ( 1 - \\beta ) \\pmb { g } + \\beta \\pmb { s }$ . Table 5 in Appendix shows how other algo",
+        "bbox": [
+            575,
+            517,
+            823,
+            587
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "rithms like Adam, Adagrad, etc. can be represented in this manner. We keep the update $\\mathcal { U }$ to be linear in the gradient $\\textbf {  { g } }$ , whereas $\\nu$ can be more complicated. This implies that while the parameter update step $\\mathcal { U }$ is relatively resilient to receiving a biased gradient $\\textbf {  { g } }$ while $\\nu$ can be much more sensitive. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            641
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Compute optimizer state globally, apply locally. When updating the optimizer state of the base algorithm, we use only the gradient computed at the server parameters. Further, they remain fixed throughout the local updates of the clients. This ensures that these optimizer state remain unbiased and representative of the global function $f ( \\cdot )$ . At the end of the round, the server performs ",
+        "bbox": [
+            173,
+            656,
+            825,
+            713
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3b921ad916d896daf887384a476c2ca781b152c0dc7c65dbd892d2fd031e2459.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\boldsymbol { s } \\gets \\mathcal { V } \\Big ( \\frac { 1 } { | \\mathcal { S } | } \\sum _ { i \\in \\mathcal { S } } \\nabla f _ { i } ( \\boldsymbol { x } ) , \\boldsymbol { s } \\Big ) , } \\\\ & { \\nabla f _ { i } ( \\boldsymbol { x } ) = \\frac { 1 } { n _ { i } } \\sum _ { \\nu = 1 } ^ { n _ { i } } \\nabla f _ { i } ( \\boldsymbol { x } ; \\zeta _ { i , \\nu } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            717,
+            612,
+            767
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that we use full-batch gradients computed at the server parameters $_ { \\textbf { \\em x } }$ , not client parameters $\\mathbf { \\nabla } _ { \\mathbf { \\psi } _ { 3 } } \\psi _ { i }$ ",
+        "bbox": [
+            171,
+            770,
+            821,
+            785
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Local client updates. Each client $i \\in S$ performs $K$ updates using $\\mathcal { U }$ of the base algorithm and a minibatch gradient. There are two variants possible corresponding to $\\mathbf { M M E }$ and MIMELITE differentiated using colored boxes. Starting from ${ \\pmb y } _ { i }  { \\pmb x }$ , repeat the following $K$ times ",
+        "bbox": [
+            173,
+            797,
+            825,
+            843
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/74813e54c9d5e75b3d93b5ff5056caabcf21e9af05d9f7a11e05e63b4000fde8.jpg",
+        "text": "$$\n{ \\pmb y } _ { i } \\gets { \\pmb y } _ { i } - \\eta \\mathcal { U } ( { \\pmb g } _ { i } , { \\pmb s } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            848,
+            570,
+            866
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { g } _ { i } \\gets \\nabla f _ { i } ( \\pmb { y } _ { i } ; \\zeta )$ for MIMELITE, and $\\begin{array} { r } { \\pmb { g } _ { i }  \\nabla f _ { i } ( \\pmb { y } _ { i } ; \\zeta ) - \\nabla f _ { i } ( \\pmb { x } ; \\zeta ) + \\frac { 1 } { | \\mathcal { S } | } \\sum _ { j \\in \\mathcal { S } } \\nabla f _ { j } ( \\pmb { x } ) } \\end{array}$ for MIME. MIMELITE simply uses the local minibatch gradient whereas MIME uses an SVRG ",
+        "bbox": [
+            174,
+            872,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "style correction [27]. This is done to reduce the noise from sampling a local mini-batch. While this correction yields faster rates in theory (and in practice for convex problems), in deep learning applications we found that MIMELITE closely matches the performance of MIME. ",
+        "bbox": [
+            173,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, there are two modifications made in practical FL: we weight all averages across the clients by the number of datapoints $n _ { i }$ [43], and we perform $K$ epochs instead of $K$ steps [66]. ",
+        "bbox": [
+            171,
+            138,
+            823,
+            167
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Theoretical analysis of Mime ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            185,
+            446,
+            203
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1 summarizes the rates of MIME (highlighted in blue) and MIMELITE (highlighted in green) and compares them to SERVER-ONLY methods when using SGD, Adam and momentum methods as the base algorithms. We will first examine the convergence of MIME and MIMELITE with a generic base optimizer and show that its properties are preserved in the federated setting. We then examine a specific momentum based base optimizer, and prove that Mime and MimeLite can be asymptotically faster than the best server-only method. This is the first result to prove the usefulness of local steps and demonstrate asymptotic speed-ups. ",
+        "bbox": [
+            173,
+            215,
+            825,
+            315
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Convergence with a generic base optimizer ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            321,
+            511,
+            337
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We will prove a generic reduction result demonstrating that if the underlying base algorithm converges, and is robust to slight perturbations, then MIME and MIMELITE also preserve the convergence of the algorithm when applied to the federated setting with additinoal local steps. ",
+        "bbox": [
+            174,
+            344,
+            825,
+            386
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem I. Suppose that we have $G ^ { 2 }$ inter-client gradient variance (A1), $L$ -smooth $\\left\\{ f _ { i } \\right\\} \\left( \\mathbf { A } 2 ^ { * } \\right)$ , and $\\sigma ^ { 2 }$ intra-client gradient variance (A3). Further, suppose that the updater $\\mathcal { U }$ of our baseoptimizer $\\boldsymbol { B } = ( \\boldsymbol { \\mathcal { U } } , \\boldsymbol { \\mathcal { V } } )$ satisfies i) linearity for a fixed state s: $\\mathcal { U } ( \\pmb { g } _ { 1 } + \\pmb { g } _ { 2 } ; \\pmb { s } ) = \\mathcal { U } ( \\pmb { g } _ { 1 } ; \\pmb { s } ) + \\mathcal { U } ( \\pmb { g } _ { 2 } ; \\pmb { s } )$ , and ii) Lipschitzness: $\\| \\mathcal { U } ( \\pmb { g } ; \\pmb { s } ) \\| \\leq B \\| \\pmb { g } \\|$ for some $B \\geq 0$ . Then, running MIME $o r$ MIMELITE with $K$ local updates and step-size $\\eta$ is equivalent to running a centralized algorithm with step-size $\\begin{array} { r } { \\tilde { \\eta } : = K \\eta \\le \\frac { \\hat { 1 } } { 2 L B } } \\end{array}$ , and updates ",
+        "bbox": [
+            173,
+            387,
+            825,
+            477
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d302f0e9cc0137336b0e7a984058f45fb6a44c82f10b0d6959b8ee444266fd4.jpg",
+        "text": "$$\n\\pmb { x } _ { t }  \\pmb { x } _ { t - 1 } - \\tilde { \\eta } \\mathcal { U } ( \\pmb { g } _ { t } + \\pmb { e } _ { t } , \\pmb { s } _ { t - 1 } ) , a n\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            479,
+            622,
+            496
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "an unbiased gradient $\\mathbb { E } _ { t } [ { \\pmb { g } } _ { t } ] = \\nabla f ( { \\pmb { x } } _ { t - 1 } )$ , with variance bounded as ",
+        "bbox": [
+            173,
+            518,
+            624,
+            535
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c3ea6fc2e3b43489d1c4bdb680fd700fcd975cbc1417e2e301e83805486ad3bd.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } _ { t } \\Vert { \\pmb { g } } _ { t } - \\nabla f ( { \\pmb x } _ { t - 1 } ) \\Vert ^ { 2 } \\leq \\left\\{ \\begin{array} { l l } { \\frac { G ^ { 2 } } { S } } & { \\mathrm { ~ M I M E ~ } , } \\\\ { \\frac { G ^ { 2 } } { S } + \\frac { \\sigma ^ { 2 } } { K S } } & { \\mathrm { ~ M I M E L I T E ~ } . } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            536,
+            673,
+            578
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and finally a small error bounded as ",
+        "bbox": [
+            174,
+            579,
+            415,
+            594
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fcd1bda1966a381fca1994cc0c389f9be0bba4ef02bd7eac485d284e944048a5.jpg",
+        "text": "$$\n\\begin{array} { r } { \\frac { 1 } { B ^ { 2 } L ^ { 2 } \\tilde { \\eta } ^ { 2 } } \\mathbb { E } _ { t } \\Vert e _ { t } \\Vert ^ { 2 } \\leq \\left\\{ \\begin{array} { l l } { \\mathbb { E } _ { t } \\Vert g _ { t } \\Vert ^ { 2 } } & { \\mathrm { ~ M I M E ~ , } } \\\\ { \\mathbb { E } _ { t } \\Vert g _ { t } \\Vert ^ { 2 } + G ^ { 2 } + \\frac { \\sigma ^ { 2 } } { K } } & { \\mathrm { ~ M I M E L I T E ~ . } } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            595,
+            694,
+            638
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here, we have proven that MIME and MIMELITE truly mimic the centralized base algorithm with very small perturbations—the magnitude of $e _ { t }$ is $\\mathcal { O } ( \\bar { \\eta } ^ { 2 } )$ . The key to the result is the linearity of the parameter update step $\\mathcal { U } ( \\cdot ; s )$ . By separating the base optimizer into a very simple parameter step $\\mathcal { U }$ and a more complicated optimizer state update step $\\nu$ , we can ensure that commonly used algorithms such as momentum, Adam, Adagrad, and others all satisfy this property. Armed with this general reduction, we can easily obtain specific convergence results. ",
+        "bbox": [
+            173,
+            646,
+            826,
+            731
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Corollary $\\mathbf { I I }$ ((Mime/MimeLite) with SGD). Given that the conditions in Theorem $I$ are satisfied, let us run $T$ rounds with $K$ local steps using SGD as the base optimizer and output ${ \\pmb x } ^ { o u t }$ . This output satisfies $\\mathbb { E } \\| \\nabla f ( \\pmb { x } ^ { o u t } ) \\| ^ { 2 } \\leq \\epsilon$ for $F : = f ( \\pmb { x } _ { 0 } ) - f ^ { \\star }$ , $\\tilde { G } ^ { 2 } : = G ^ { 2 } \\stackrel { \\sim } { + } \\sigma ^ { 2 } / K$ and ",
+        "bbox": [
+            173,
+            732,
+            823,
+            777
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• $\\mu$ -PL inequality: $\\begin{array} { r } { \\eta = \\tilde { \\mathcal { O } } \\big ( \\frac { 1 } { \\mu K T } \\big ) } \\end{array}$ , and ",
+        "bbox": [
+            184,
+            782,
+            446,
+            800
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/931bddca850b6059f0e3f2bac1fe3d1d3e49d84b79b7e2188301299c049c4009.jpg",
+        "text": "$$\n\\begin{array} { r l } & { T = \\left\\{ \\begin{array} { l l } { \\tilde { \\mathcal { O } } \\left( \\frac { L G ^ { 2 } } { \\mu S \\epsilon } + \\frac { L F } { \\mu } \\log \\left( \\frac { 1 } { \\epsilon } \\right) \\right) } & { \\mathrm { ~ M I M E ~ } , } \\\\ { \\tilde { \\mathcal { O } } \\left( \\frac { L G ^ { 2 } } { \\mu S \\epsilon } + \\frac { L \\tilde { \\mathcal { G } } } { \\mu \\sqrt { \\epsilon } } + \\frac { L F } { \\mu } \\log \\left( \\frac { 1 } { \\epsilon } \\right) \\right) } & { \\mathrm { ~ M I M E L I T E ~ } . } \\end{array} \\right. } \\\\ & { = \\mathcal { O } \\big ( \\sqrt { \\frac { F S } { L G ^ { 2 } T K ^ { 2 } } } \\big ) , a n d } \\\\ & { T = \\left\\{ \\begin{array} { l l } { \\mathcal { O } \\Big ( \\frac { L G ^ { 2 } F } { S \\epsilon ^ { 2 } } + \\frac { L F } { \\epsilon } \\Big ) } & { \\mathrm { ~ M I M E ~ } , } \\\\ { \\mathcal { O } \\Big ( \\frac { L G ^ { 2 } F } { S \\epsilon ^ { 2 } } + \\frac { L ^ { 2 } G F } { \\epsilon ^ { 3 / 2 } } + \\frac { L F } { \\epsilon } \\Big ) } & { \\mathrm { ~ M I M E L I T E ~ } . } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            797,
+            692,
+            915
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/623799e437f4dcf8d01f900963f6ffb46a556db1f6f7b8a9fc0fdd170dda4425.jpg",
+        "table_caption": [
+            "Table 1: Number of communication rounds required to reach $\\| \\nabla f ( \\pmb { x } ) \\| ^ { 2 } \\leq \\epsilon$ (log factors are ignored) with $S$ clients sampled each round. All analyses except SCAFFOLD assume $G ^ { 2 }$ bounded gradient dissimilarity (A1). All analyses assume $L$ -smooth losses, except MimeLiteMVR and MimeMVR, which only assume $\\delta$ bounded Hessian dissimilarity (A2). Convergence of SCAFFOLD depends on the total number of clients $N$ which is potentially infinite. FEDAVG and MIMELITE are slightly slower than the server-only methods due to additional drift terms in most cases. MIME is the fastest and either matches or improves upon the optimal statistical rates (first term in the rates). In fact, MimeMVR and MimeLiteMVR beat lower bounds for any server-only method when $\\delta \\ll L$ . "
+        ],
+        "table_footnote": [
+            "a Num. clients $. N )$ can be same order as num. total rounds or even $\\infty$ , making the bounds vacuous. b Adam requires large batch-size $S \\ge G ^ { 2 } / \\epsilon$ to converge [50, 75]. Convergence of FedAdam with client sampling is unknown ([49] only analyze with full client participation). c Requires $K \\stackrel { \\smile } { \\geq } \\sigma ^ { 2 } / G ^ { 2 }$ number of local updates. Typically, intra-client variance is small $( \\sigma ^ { 2 } \\lesssim G ^ { 2 } )$ . d Requires $K \\ge L / \\delta$ number of local updates. Faster than the lower bound (and hence any SERVERONLY algorithm) when $\\delta \\ll L$ i.e. our methods can take advantage of Hessian similarity, whereas SERVER-ONLY methods cannot. In worst case, $\\delta \\approx L$ and all methods are comparable. "
+        ],
+        "table_body": "<table><tr><td>Algorithm</td><td colspan=\"5\">Non-convex</td><td colspan=\"4\"> μ-PL inequality</td></tr><tr><td colspan=\"2\">SCAFFOLDa [32]</td><td colspan=\"4\">2 （） L E</td><td>+</td><td colspan=\"3\"></td></tr><tr><td colspan=\"2\">SGD SERVER-ONLY [21]</td><td colspan=\"4\">LG² +</td><td>G²</td><td>+</td><td></td><td></td></tr><tr><td>MimeLiteSGD=</td><td>FedAvgSGD C</td><td colspan=\"2\">S E LG² L²G</td><td>+</td><td></td><td>uSe G²</td><td>+</td><td>μ LG</td><td>+/</td></tr><tr><td>MimeSGD</td><td></td><td>S+ LG² +</td><td>3/2 L</td><td></td><td>μSE G²</td><td></td><td>L</td><td>HVE</td><td>μ</td></tr><tr><td>ADAM</td><td></td><td>Se² L</td><td>E</td><td></td><td></td><td>μSE</td><td>+ μ</td><td></td><td></td></tr><tr><td></td><td>SERVER-ONLY [75]b</td><td colspan=\"4\">-G2/s</td><td></td><td></td><td></td><td></td></tr><tr><td>MimeAdamb</td><td>MimeLiteAdambc</td><td colspan=\"4\">LVS E-G2/S</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td colspan=\"4\">L e-G²/S</td><td></td><td></td><td></td><td></td></tr><tr><td>SERVER-ONLY [14]</td><td>Momentum Variance Reduction (MVR)</td><td colspan=\"4\">LG G + S3/2</td><td></td><td></td><td></td><td></td></tr><tr><td>MimeLiteMVRd</td><td></td><td colspan=\"4\">Se E δ(G+σ) G²+² 8</td><td></td><td></td><td></td><td></td></tr><tr><td>MimeMVRd</td><td></td><td colspan=\"4\">3/2 E E 8G G²</td><td></td><td></td><td></td><td></td></tr><tr><td colspan=\"2\">SERVER-ONLY lower bound [5]</td><td>VSe3/2 2（</td><td>十 SE LG G²</td><td>E +）</td><td>2（）</td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            171,
+            214,
+            825,
+            558
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "If we take a sufficient number of local steps $K \\ge G ^ { 2 } / \\sigma ^ { 2 }$ , then we have ${ \\tilde { G } } = { \\mathcal { O } } ( G )$ in the above rates. On comparing with the rates in Table 1 for SERVER-ONLY SGD, we see that MIME exactly matches its rates. MIMELITE matches the asymptotic term but has a few higher order terms. Note that when using SGD as the base optimizer, MIMELITE becomes exactly the same as FEDAVG and hence has the same rate of convergence. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            736
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Corollary III ((Mime/MimeLite) with Adam). Suppose that the conditions in Theorem $I$ are satisfied, and further $| \\nabla _ { j } f _ { i } ( { \\pmb x } ) | \\le H$ for any coordinate $j \\in [ d ]$ . Then let us run $T$ rounds using Adam as the base optimizer with $K$ local steps, $\\beta _ { 1 } = 0$ , $\\varepsilon _ { 0 } > 0$ , $\\eta \\leq \\varepsilon _ { 0 } ^ { 2 } / K L ( H + \\varepsilon _ { 0 } )$ , and any $\\beta _ { 2 } \\in [ 0 , 1 )$ . Output ${ \\pmb x } ^ { o u t }$ chosen randomly from $\\{ \\pmb { x } _ { 1 } , \\hdots \\pmb { x } _ { T } \\}$ satisfies $\\mathbb { E } \\| \\nabla f ( \\pmb { x } ^ { o u t } ) \\| ^ { 2 } \\leq \\epsilon _ { \\mathcal { I } }$ for ",
+        "bbox": [
+            171,
+            739,
+            825,
+            799
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d51e2b448d40be2ee75686758c2e6613eb72713f7f60e05a5b1db743c29d8472.jpg",
+        "text": "$$\n\\begin{array} { r l } & { T = \\left\\{ \\begin{array} { l l } { \\mathcal { O } \\Big ( \\frac { L F ( H + \\varepsilon _ { 0 } ) ^ { 2 } } { \\varepsilon _ { 0 } ^ { 2 } ( \\epsilon - \\tilde { G } ^ { 2 } / S ) } \\Big ) } & { \\quad \\mathrm { M I M E ~ A d a m ~ } , } \\\\ { \\mathcal { O } \\Big ( \\frac { L F ( H + \\varepsilon _ { 0 } ) ^ { 2 } \\sqrt { S } } { \\varepsilon _ { 0 } ^ { 2 } ( \\epsilon - \\tilde { G } ^ { 2 } / S ) } \\Big ) } & { \\quad \\mathrm { M I M E L I T E ~ A d a m ~ } . } \\end{array} \\right. } \\\\ & { \\bar { \\tau } , \\tilde { G } ^ { 2 } : = G ^ { 2 } + \\sigma ^ { 2 } / K . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            803,
+            663,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\cal F } : = f ( x _ { 0 } ) - f ^ { \\star } , \\tilde { G } ^ { 2 } : \\stackrel { \\bullet } { = } G ^ { \\dot { 2 } } + \\stackrel { \\bullet } { \\sigma } ^ { 2 } / K .$ ",
+        "bbox": [
+            173,
+            856,
+            473,
+            873
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that here $\\varepsilon _ { \\mathrm { 0 } }$ represents a small positive parameter used in Adam for regularization, and is different from the error $\\epsilon$ . Similar to the SERVER-ONLY analysis of Adam [75], we assume $\\beta _ { 1 } = 0$ ",
+        "bbox": [
+            173,
+            882,
+            823,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "and that batch size is large enough such that $S \\ge G ^ { 2 } / \\epsilon$ . A similar analysis can also be carried out for AdaGrad, and other novel variants of Adam [42]. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Circumventing server-only lower bounds ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            135,
+            498,
+            150
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The rates obtained above, while providing a safety-check, do not beat those of the SERVER-ONLY approach. The previous best rates for cross-device FL correspond to MimeLiteSGD which is $\\begin{array} { r } { \\ O ( \\frac { L G ^ { 2 } } { S \\epsilon ^ { 2 } } + \\frac { L ^ { 2 } G } { \\epsilon ^ { 3 / 2 } } ) } \\end{array}$ [34, 36, 69]. While, using a separate server-learning rate can remove the effect of the second term [33], this at best matches the rate of SERVER-ONLY SGD $\\mathcal { O } \\big ( \\textstyle \\frac { L G ^ { 2 } } { S \\epsilon ^ { 2 } } \\big )$ . This is significantly slower than simply using momentum based variance reduction (MVR) as in in the FL setting (SERVER-ONLY MVR) which has a communication complexity of ( √LGS\u000f3/2 ) [14]. Thus, even though the main reason for studying local-step methods was to improve the communication complexity, none thus far show such improvement. The above difficulty of beating SERVER-ONLY may not be surprising given the two sets of strong lower bounds known. ",
+        "bbox": [
+            173,
+            160,
+            825,
+            297
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Necessity of local steps. Firstly, [5] show a gradient oracle lower bound of $\\Omega \\big ( \\frac { L G } { \\sqrt { S } \\epsilon ^ { 3 / 2 } } \\big )$ This matches the complexity of MVR, and hence at first glance it seems that SERVER-ONLY MVR is optimal. However, the lower bound is really only on the number of gradients computed and not on the number of clients sampled (sample complexity) [18], or number of rounds of communication required. In particular, multiple local updates increases number of gradients computed without needing additional communication offers us a potential way to side-step such lower bounds. A careful analysis of the bias introduced as a result of such local steps is a key part of our analysis. ",
+        "bbox": [
+            173,
+            309,
+            825,
+            411
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Necessity of $\\delta$ -BHD. A second set of lower bounds directly study the number of communication rounds required in heterogeneous optimization [6, 69]. These results prove that there exist settings where local steps provide no advantage and SERVER-ONLY methods are optimal. This however contradicts real world experimental evidence [43]. As before, the disparity arises due to the contrived settings considered by the lower bounds. For distributed optimization (with full client participation) and convex quadratic objectives, $\\delta$ -BHD (A2) was shown to be a sufficient [54, 51] and necessary [6] condition to circumvent these lower bounds and yield highly performant methods. We similarly leverage $\\delta$ -BHD (A2) to design novel methods which significantly extend prior results to i) all smooth non-convex functions (not just quadratics), and ii) cross-device FL with client sampling. ",
+        "bbox": [
+            173,
+            424,
+            825,
+            551
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now state our convergence results with momentum based variance reduction (MVR) as the basealgorithm since it is known to be optimal in the SERVER-ONLY setting. ",
+        "bbox": [
+            173,
+            556,
+            821,
+            585
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem IV. For $L$ -smooth $f$ with $G ^ { 2 }$ gradient dissimilarity (A1), $\\delta$ Hessian dissimilarity (A2) and $F : = ( f ( \\pmb { x } ^ { 0 } ) - f ^ { \\star } )$ , let us run MVR as the base algorithm for $T$ rounds with $K \\ge L / \\delta$ local steps and generate an output ${ \\pmb x } ^ { o u t }$ . This output satisfies $\\bar { \\mathbb { E } } \\| \\nabla f ( \\pmb { x } ^ { o u t } ) \\| ^ { 2 } \\leq \\epsilon$ for ",
+        "bbox": [
+            176,
+            588,
+            825,
+            631
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• $M i m e M V R$ : $\\begin{array} { r } { \\eta = \\mathcal { O } \\Big ( \\operatorname* { m i n } \\big ( \\frac { 1 } { \\delta K } , \\big ( \\frac { S F } { G ^ { 2 } T K ^ { 3 } } \\big ) ^ { 1 / 3 } \\Big ) \\Big ) } \\end{array}$ , momentum $\\begin{array} { r } { \\beta = 1 - \\mathcal { O } \\big ( \\frac { \\delta ^ { 2 } S ^ { 2 / 3 } } { ( T G ^ { 2 } ) ^ { 2 / 3 } } \\big ) } \\end{array}$ ( δ2S2/3(T G2)2/3 ), and ",
+        "bbox": [
+            186,
+            631,
+            779,
+            654
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "MimeLiteMVR : $\\begin{array} { r } { \\eta = \\mathcal { O } \\Big ( \\operatorname* { m i n } \\big ( \\frac { 1 } { \\delta K } , \\big ( \\frac { \\mathbf { v } } { \\hat { G } ^ { 2 } T K ^ { 3 } } \\big ) ^ { 1 / 3 } \\Big ) \\Big ) } \\end{array}$ , momentum $\\begin{array} { r } { \\beta = 1 - \\mathcal { O } ( \\frac { \\delta ^ { 2 } } { ( T \\hat { G } ^ { 2 } ) ^ { 2 / 3 } } ) } \\end{array}$ ",
+        "bbox": [
+            192,
+            685,
+            803,
+            708
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here, we define ${ \\hat { G } } ^ { 2 } : = G ^ { 2 } + \\sigma ^ { 2 }$ and the expectation in $\\mathbb { E } \\| \\nabla ^ { \\in } f ( \\pmb { x } ^ { \\mathrm { o u t } } ) \\| ^ { 2 } \\le \\epsilon$ is taken both over the sampling of the clients during the running of the algorithm, the sampling of the mini-batches in local updates, and the choice of $\\pmb { x } ^ { \\mathrm { o u t } }$ (which is chosen randomly from the client iterates $\\mathbf { \\nabla } _ { \\mathbf { \\psi } _ { 3 } } \\mathbf { \\psi } _ { 2 } \\qquad \\mathbf { \\psi } _ { 3 } \\mathbf { \\psi } _ { 4 } \\qquad \\mathbf { \\psi } _ { 3 } \\mathbf { \\psi } _ { 4 } \\qquad \\mathbf { \\psi } _ { 3 } \\mathbf { \\psi } _ { 4 } \\mathbf { \\psi } _ { 3 } \\qquad \\mathbf { \\psi } _ { 4 } \\mathbf { \\psi } _ { 4 } \\mathbf { \\psi } _ { 3 } \\mathbf { \\psi } _ { 4 } \\mathbf { \\psi } _ { 4 } \\mathbf { \\psi } _ { 3 } \\qquad \\mathbf { \\psi } _ { 3 } \\mathbf { \\psi } _ { 4 } \\mathbf { \\psi } _ { 4 } \\mathbf { \\psi } _ { 3 } \\mathbf { \\psi } _ { 4 } \\mathbf { \\psi } _ { 4 }$ ). ",
+        "bbox": [
+            174,
+            736,
+            823,
+            779
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Remarkably, the rates of our methods are independent of $L$ and only depend on $\\delta$ . Thus, when $\\delta \\leq L$ and $\\bar { \\delta } \\leq L / _ { S }$ for MimeMVR and MimeLiteMVR, the rates beat the server only lower bound of $\\Omega \\big ( \\frac { L G } { \\sqrt { S } \\epsilon ^ { 3 / 2 } } \\big )$ . In fact, if the Hessian variance is small and $\\delta \\approx 0$ , our methods only need $\\mathcal { O } ( 1 / \\epsilon )$ rounds to communicate. Intuitively, our results show that local steps are very useful when heterogeneity (represented by $\\delta$ ) is smaller than optimization difficulty (captured by smoothness constant $L$ ). ",
+        "bbox": [
+            173,
+            784,
+            825,
+            859
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "MimeMVR uses a momentum parameter $\\beta$ of the order of $( 1 - \\mathcal { O } ( T G ^ { 2 } ) ^ { - 2 / 3 } )$ i.e. as $T$ increases, $\\beta$ asymptotically approaches 1. In contrast, previous analyses of distributed momentum (e.g. [73]) prove rates of the form $\\frac { G ^ { 2 } } { S ( 1 - \\beta ) \\epsilon ^ { 2 } }$ , which are worse than that of standard SGD by a factor of $\\frac { 1 } { 1 - \\beta }$ . ",
+        "bbox": [
+            174,
+            866,
+            825,
+            915
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/1ea55dae1f107ef5e01c171ee61180c266dc81e1d9e130ceb449cf46fad9c055.jpg",
+        "image_caption": [
+            "Figure 1: Mime, MimeLite, FedAvg, Scaffold, FedProx, and Loc-Mime with $\\mathrm { S G D + }$ momentum using 10 local epochs, run on EMNIST62 and a 2 hidden layer (300u-100) MLP. (Left) Mime and MimeLite are nearly identical and outperform the rest $7 \\times$ faster). (Center) Mime makes better use of momentum than FedAvg, with a large increase in performance. (Right) Locally adapting momentum slows down convergence and makes it more unstable. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            87,
+            818,
+            217
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Thus, ours is also the first result which theoretically showcases the usefulness of using large momentum in distributed and federated learning. While we only prove the utility of local steps for MimeMVR, we believe our theory can be extended to other local update methods as well. ",
+        "bbox": [
+            176,
+            303,
+            821,
+            344
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our analysis is highly non-trivial and involves two crucial ingredients: i) computing the momentum at the server level to ensure that it remains unbiased and then applying it locally during every client update to reduce variance, and ii) carefully keeping track of the bias introduced via additional local steps. Our experiments (Sec. 5) verify our theoretical insights are indeed applicable in deep learning settings as well. See App. B for a proof sketch and App. G–H detailed proofs. ",
+        "bbox": [
+            174,
+            351,
+            825,
+            421
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Experimental analysis on real world datasets ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            434,
+            578,
+            450
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We run experiments on natively federated datasets to confirm our theory and accurately measure real world performance. Our main findings are i) MIME and MIMELITE consistently outperform FEDAVG, and ii) momentum and adaptivity significantly improves performance. ",
+        "bbox": [
+            176,
+            465,
+            823,
+            507
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 Setup",
+        "text_level": 1,
+        "bbox": [
+            173,
+            513,
+            253,
+            529
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Algorithms. We consider three (meta) algorithms: FEDAVG, MIME, and MIMELITE. Each of these adapt four base optimizers: SGD, momentum, Adam, and Adagrad. ",
+        "bbox": [
+            176,
+            534,
+            823,
+            560
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "FEDAVG follows [49] who run multiple epochs of SGD on each client sampled, and then aggregate the net client updates. This aggregated update is used as a pseudo-gradient in the base optimizer (called server optimizer). The learning rate for the server optimizer is fixed to 1 as in [67]. This is done to ensure all algorithms have the same number of hyper-parameters. ",
+        "bbox": [
+            178,
+            560,
+            820,
+            614
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "MIME and MIMELITE follow Algorithm 4 and also run a fixed number of epochs on the client. However, note that this requires communicating both the full local-batch gradient as well as the parameter updates doubling the communication required to be sent by the client. For a fairer comparison, we split the sampled clients in MIME and MIMELITE into two groups–the first communicates only full local-batch gradient and the latter communicates only parameter updates. Thus, all methods have equal client communication to the server. This variant retains the convergence guarantees up to constants (details in the Appendix). We also run Loc-MIME where instead of keeping the global optimizer state fixed, we update it locally within the client. The optimizer state is reset after the round finishes. In all methods, aggregation is weighted by the number of samples on the clients. ",
+        "bbox": [
+            174,
+            616,
+            825,
+            739
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Datasets and models. We run five simulations on three real-world federated datasets: EMNIST62 with i) a linear classifier, ii) an MLP, and iii) a CNN, iv) a charRNN on Shakespeare, and v) an LSTM for next word prediction on StackOverflow, all accessed through Tensorflow Federated [60]. The learning rates were individually tuned and other optimizer hyper-parameters such as $\\beta$ for momentum, $\\beta _ { 1 }$ , $\\beta _ { 2 }$ , $\\varepsilon _ { \\mathrm { 0 } }$ for Adam and AdaGrad were left to their default values, unless explicitly stated otherwise. We refer to Appendix C for additional setup details and discussion. ",
+        "bbox": [
+            173,
+            746,
+            825,
+            829
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 Ablation and comparative study ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            835,
+            436,
+            849
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to study the different algorithms, we train a 2 hidden layer ( $3 0 0 \\mu$ -100) MLP on EMNIST62 with 10 local epochs for 1k rounds and use SGD $^ +$ momentum (with tuned $\\beta$ ) as the base optimizer. ",
+        "bbox": [
+            173,
+            851,
+            823,
+            878
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Mime $\\approx$ MimeLite $>$ FedAvg $>$ SCAFFOLD $>$ FedProx. Fig. 1 (left) shows MIME and MIMELITE have nearly identical performance, and are about $7 \\times$ faster than FedAvg. This implies our strategy of applying momentum to client updates is faster than simply using server momentum. FedProx [40] uses an additional regularizer $\\mu$ tuned over [0.1, 0.5, 1] $\\mu = 0$ is the same as FedAvg). Regularization does not seem to reduce client drift but still slows down convergence [66]. SCAFFOLD [32] is also slower than Mime and FedAvg in this setup. This is because in cross-device setting with a large number of clients $N = 3 . 4 k )$ ) means that each client is visited less than 6 times during the entire training (20 clients per round for 1k rounds). This means that the correction term utilized by SCAFFOLD uses control-variates which are quite stale (computed about 200 rounds ago) which slows down the convergence. In contrast, the SVRG correction term in Mime is computed using clients sampled in the current or previous rounds, and so is much more accurate. ",
+        "bbox": [
+            174,
+            882,
+            820,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/1e5fd3e08536214ca5c7b9210c3b8a8c8d775d2ef2c8d99f10229341afdd0fed.jpg",
+        "table_caption": [
+            "Table 2: Validation $\\%$ accuracies after training for 1000 rounds. Best results for each dataset is underlined and the best within each base optimizer is bolded. The number of clients sampled per round has been reduced for MIME and MIMELITE to ensure all methods have equal client and server communication. Final accuracies obtained by MIME and MIMELITE are competitive with FEDAVG, especially with adaptive base optimizers. FEDAVG seems unstable with Adam. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\">SGD</td><td colspan=\"2\">EMNIST logistic StackOverflow</td><td colspan=\"2\">EMNIST CNN Shakespeare</td></tr><tr><td>FedAvgSGD</td><td>66.8</td><td>85.8 56.7</td><td>23.8</td></tr><tr><td>MimeLiteSGD</td><td>66.8</td><td>85.8 56.7</td><td>23.8</td></tr><tr><td rowspan=\"3\">MimeSGD MOMENTUM</td><td>67.4</td><td>85.3</td><td>56.1</td><td>12.5</td></tr><tr><td>FedAvgMom</td><td>67.4</td><td>85.7 55.4</td><td>22.2</td></tr><tr><td>MimeLiteMom</td><td>67.4 86.0</td><td>49.8</td><td>19.9</td></tr><tr><td rowspan=\"3\">ADAM</td><td>MimeMom</td><td>67.5</td><td>85.9</td><td>53.6</td><td>19.3</td></tr><tr><td>FedAvgAdam</td><td>67.3</td><td>85.9</td><td>18.5</td><td>3.2</td></tr><tr><td>MimeLiteAdam</td><td>68.0</td><td>86.4</td><td>54.0</td><td>21.5</td></tr><tr><td rowspan=\"3\">ADAGRAD</td><td>MimeAdam</td><td>68.0</td><td>86.6</td><td>54.1</td><td>22.8</td></tr><tr><td>FedAvgAdagrad</td><td>67.6</td><td>86.3</td><td>55.5</td><td>24.2</td></tr><tr><td>MimeLiteAdagrad</td><td>66.6</td><td>85.5</td><td>56.8</td><td>23.8</td></tr><tr><td></td><td>MimeAdagrad</td><td>67.4</td><td>86.3</td><td>57.1</td><td>14.7</td></tr></table>",
+        "bbox": [
+            191,
+            166,
+            794,
+            383
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            398,
+            825,
+            523
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "With momentum $>$ without momentum. Fig. 1 (center) examines the impact of momentum on FedAvg and Mime. Momentum slightly improves the performance of FedAvg, whereas it has a significant impact on the performance of Mime. This is also in line with our theory and confirms that Mime’s strategy of applying it locally at every client update makes better use of momentum. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            583
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Fixed $>$ locally updated optimizer state. Finally, we check how the performance of Mime changes if instead of keeping the momentum fixed throughout a round, we let it change. The latter is a way to combine global and local momentum. The momentum is reset at the end of the round ignoring the changes the clients make to it. Fig. 1 (right) shows that this worsens the performance, confirming that it is better to keep the global optimizer state fixed as predicted by our theory. ",
+        "bbox": [
+            173,
+            584,
+            825,
+            654
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Together, the above observations validate all aspects of Mime (and MimeLite) design: compute statistics at the server level, and apply them unchanged at every client update. ",
+        "bbox": [
+            174,
+            660,
+            823,
+            689
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 Large scale comparison with equal server and client communication ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            695,
+            687,
+            710
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We perform a larger scale study closely matching the setup of [49]. For both MIME and MIMELITE, only half the clients compute and transmit the updated parameters, and other half transmit the full local-batch gradients. Hence, client to server communication cost is the same for all methods for all clients. However, MIME and MIMELITE require sending additional optimization state to the clients. Hence, we also reduce the number of clients sampled in each round to ensure sum total of communication at each round is $4 0 \\times$ model size for EMNIST and Shakespeare experiments, and $1 0 0 \\times$ model size for the StackOverflow next word prediction experiment. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            808
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Since we only perform 1 local epoch, the hyper-parameters (e.g. epsilon for adaptive methods) are more carefully chosen following [49], and MIME and MIMELITE use significantly fewer clients per round, the difference between FEDAVG and MIME is smaller here. Table 2 summarizes the results. ",
+        "bbox": [
+            176,
+            811,
+            823,
+            852
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For the image classification tasks of EMNIST62 logistic and EMNIST62 CNN, Mime and MimeLite with Adam achieve the best performance. Using momentum (both with SGD and in Adam) significantly improves their performance. In contrast, FedAvgAdam is more unstable with worse performance. This is because FedAvg is excessively sensitive to hyperparameters (cf. App. E). ",
+        "bbox": [
+            176,
+            854,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We next consider the character prediction task on Shakespeare dataset, and next word prediction on StackOverflow. Here, the momentum based methods (SGD $^ +$ momentum and Adam) are slower than their non-momentum counterparts (vanilla SGD and AdaGrad). This is because the mini-batch gradients in these tasks are sparse, with the gradients corresponding to tokens not in the mini-batch being zero. This sparsity structure is however destroyed when using momentum or Adam. For the same reason, Mime which uses an SVRG correction also significantly increases the gradient density. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            174
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Discussion. For traditional tasks such as image classification, we observe that Mime (especially with Adam) usually outperforms MimeLite which in turn outperforms FedAvg. These methods are able to successfully leverage momentum and adaptivity to improve performance. For tasks where the client gradients are sparse, the SVRG correction used by Mime hinders performance. Adapting our techniques to work with sparse gradients (a la Yogi [ \\` 75]) could lead to further improvements. Also, note that we reduce communication by na¨ıvely reducing the number of participating clients per round. More sophisticated approaches to save on client communication including quantization or sparsification [58, 3], or even novel algorithmic innovations [1] could be explored. Further, server communication could be reduced using memory efficient optimizers e.g. AdaFactor [55] or SM3 [4]. ",
+        "bbox": [
+            173,
+            190,
+            825,
+            316
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            321,
+            299,
+            337
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our work initiated a formal study of the cross-device federated learning problem and provided theoretically justified algorithms. We introduced a new framework MIME which overcomes the natural client-heterogeneity in such a setting, and can adapt arbitrary centralized algorithms such as Adam without additional hyper-parameters. We demonstrated the superiority of MIME via strong convergence guarantees and empirical evaluations. Further, we proved that a particular instance of our method, MimeMVR, beat centralized lower-bounds, demonstrating that additional local steps can yield asymptotic improvements for the first time. We believe our analysis will be of independent interest beyond the federated setting for understanding the sample complexity of non-convex optimization, and for yielding improved analysis of decentralized optimization algorithms. ",
+        "bbox": [
+            174,
+            340,
+            825,
+            465
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            484,
+            266,
+            500
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Durmus Alp Emre Acar, Yue Zhao, Ramon Matas Navarro, Matthew Mattina, Paul N Whatmough, and Venkatesh Saligrama. Federated learning based on dynamic regularization. In International Conference on Learning Representations, 2021.   \n[2] Naman Agarwal, Ananda Theertha Suresh, Felix X. Yu, Sanjiv Kumar, and Brendan McMahan. cpSGD: Communication-efficient and differentially-private distributed SGD. In Proceedings of NeurIPS, pages 7575–7586, 2018.   \n[3] Dan Alistarh, Demjan Grubic, Jerry Li, Ryota Tomioka, and Milan Vojnovic. Qsgd: Communication-efficient sgd via gradient quantization and encoding. In Advances in Neural Information Processing Systems (NeurIPS), 2017.   \n[4] Rohan Anil, Vineet Gupta, Tomer Koren, and Yoram Singer. Memory-efficient adaptive optimization. arXiv preprint arXiv:1901.11150, 2019.   \n[5] Yossi Arjevani, Yair Carmon, John C Duchi, Dylan J Foster, Nathan Srebro, and Blake Woodworth. Lower bounds for non-convex stochastic optimization. arXiv preprint arXiv:1912.02365, 2019.   \n[6] Yossi Arjevani and Ohad Shamir. Communication complexity of distributed convex learning and optimization. In Advances in neural information processing systems, pages 1756–1764, 2015.   \n[7] Keith Bonawitz, Hubert Eichner, Wolfgang Grieskamp, Dzmitry Huba, Alex Ingerman, Vladimir Ivanov, Chloe Kiddon, Jakub Konecnˇ y, Stefano Mazzocchi, H Brendan McMahan, \\` et al. Towards federated learning at scale: System design. arXiv preprint arXiv:1902.01046, 2019.   \n[8] Keith Bonawitz, Vladimir Ivanov, Ben Kreuter, Antonio Marcedone, H. Brendan McMahan, Sarvar Patel, Daniel Ramage, Aaron Segal, and Karn Seth. Practical secure aggregation for privacy-preserving machine learning. In Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security, pages 1175–1191. ACM, 2017.   \n[9] Sebastian Caldas, Jakub Konecny, H Brendan McMahan, and Ameet Talwalkar. Expand- ˇ ing the reach of federated learning by reducing client resource requirements. arXiv preprint arXiv:1812.07210, 2018.   \n[10] Sebastian Caldas, Peter Wu, Tian Li, Jakub Konecnˇ y, H Brendan McMahan, Virginia \\` Smith, and Ameet Talwalkar. Leaf: A benchmark for federated settings. arXiv preprint arXiv:1812.01097, 2018.   \n[11] Zachary Charles and Jakub Konecnˇ y. On the outsized importance of learning rates in local \\` update methods. arXiv preprint arXiv:2007.00878, 2020.   \n[12] Gregory Cohen, Saeed Afshar, Jonathan Tapson, and Andre Van Schaik. Emnist: Extending mnist to handwritten letters. In 2017 International Joint Conference on Neural Networks (IJCNN), pages 2921–2926. IEEE, 2017.   \n[13] Ashok Cutkosky and Harsh Mehta. Momentum improves normalized SGD. arXiv preprint arXiv:2002.03305, 2020.   \n[14] Ashok Cutkosky and Francesco Orabona. Momentum-based variance reduction in non-convex SGD. In Advances in Neural Information Processing Systems, pages 15210–15219, 2019.   \n[15] Aaron Defazio and Leon Bottou. On the ineffectiveness of variance reduced optimization ´ for deep learning. In Advances in Neural Information Processing Systems, pages 1753–1763, 2019.   \n[16] Stack Exchange. Stack exchange data dump. https: // archive. org/ details/ stackexchange , 2021.   \n[17] Cong Fang, Chris Junchi Li, Zhouchen Lin, and Tong Zhang. SPIDER: Near-optimal nonconvex optimization via stochastic path-integrated differential estimator. In Advances in Neural Information Processing Systems, pages 689–699, 2018.   \n[18] Dylan J Foster, Ayush Sekhari, Ohad Shamir, Nathan Srebro, Karthik Sridharan, and Blake Woodworth. The complexity of making the gradient small in stochastic convex optimization. In Conference on Learning Theory, pages 1319–1345. PMLR, 2019.   \n[19] Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. International Conference on Learning Representations (ICLR), 2019.   \n[20] Robin C Geyer, Tassilo Klein, and Moin Nabi. Differentially private federated learning: A client level perspective. arXiv preprint arXiv:1712.07557, 2017.   \n[21] Saeed Ghadimi and Guanghui Lan. Stochastic first-and zeroth-order methods for nonconvex stochastic programming. SIAM Journal on Optimization, 23(4):2341–2368, 2013.   \n[22] Jenny Hamer, Mehryar Mohri, and Ananda Theertha Suresh. FedBoost: Communicationefficient algorithms for federated learning. In 37th International Conference on Machine Learning (ICML), 2020.   \n[23] Andrew Hard, Kurt Partridge, Cameron Nguyen, Niranjan Subrahmanya, Aishanee Shah, Pai Zhu, Ignacio Lopez Moreno, and Rajiv Mathews. Training keyword spotting models on non-iid data with federated learning. arXiv preprint arXiv:2005.10406, 2020.   \n[24] Lie He, Sai Praneeth Karimireddy, and Martin Jaggi. Secure byzantine-robust machine learning. arXiv preprint arXiv:2006.04747, 2020.   \n[25] Arne Holst. Smartphone users worldwide 2016-2021. Statista https: // web. archive. org/ web/ 20210608080335/ https: // www. statista. com/ statistics/ 330695/ number-of-smartphone-users-worldwide/ , 2019.   \n[26] Tzu-Ming Harry Hsu, Hang Qi, and Matthew Brown. Measuring the effects of non-identical data distribution for federated visual classification. arXiv preprint arXiv:1909.06335, 2019.   \n[27] Rie Johnson and Tong Zhang. Accelerating stochastic gradient descent using predictive variance reduction. In Advances in neural information processing systems, pages 315–323, 2013.   \n[28] Peter Kairouz, H Brendan McMahan, Brendan Avent, Aurelien Bellet, Mehdi Bennis, Ar- ´ jun Nitin Bhagoji, Keith Bonawitz, Zachary Charles, Graham Cormode, Rachel Cummings, et al. Advances and open problems in federated learning. arXiv preprint arXiv:1912.04977, 2019.   \n[29] Hamed Karimi, Julie Nutini, and Mark Schmidt. Linear convergence of gradient and proximalgradient methods under the polyak-łojasiewicz condition. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pages 795–811. Springer, 2016.   \n[30] Sai Praneeth Karimireddy, Lie He, and Martin Jaggi. Learning from history for byzantine robust optimization. In 38th International Conference on Machine Learning (ICML), 2021.   \n[31] Sai Praneeth Karimireddy, Martin Jaggi, Satyen Kale, Mehryar Mohri, Sashank J Reddi, Sebastian U Stich, and Ananda Theertha Suresh. Mime: Mimicking centralized stochastic algorithms in federated learning. arXiv preprint arXiv:2008.03606, 2020.   \n[32] Sai Praneeth Karimireddy, Satyen Kale, Mehryar Mohri, Sashank J Reddi, Sebastian U Stich, and Ananda Theertha Suresh. SCAFFOLD: Stochastic controlled averaging for on-device federated learning. In 37th International Conference on Machine Learning (ICML), 2020.   \n[33] Sai Praneeth Karimireddy, Quentin Rebjock, Sebastian U. Stich, and Martin Jaggi. Error feedback fixes SignSGD and other gradient compression schemes. In 36th International Conference on Machine Learning (ICML), 2019.   \n[34] Ahmed Khaled, Konstantin Mishchenko, and Peter Richtarik. Tighter theory for local SGD on ´ indentical and heterogeneous data. In Proceedings of AISTATS, 2020.   \n[35] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   \n[36] Anastasia Koloskova, Nicolas Loizou, Sadra Boreiri, Martin Jaggi, and Sebastian U Stich. A unified theory of decentralized SGD with changing topology and local updates. In $3 7 t h$ International Conference on Machine Learning (ICML), 2020.   \n[37] Jakub Konecnˇ y, H. Brendan McMahan, Daniel Ramage, and Peter Richt \\` arik. Feder- ´ ated optimization: Distributed machine learning for on-device intelligence. arXiv preprint arXiv:1610.02527, 2016.   \n[38] Jakub Konecnˇ y, H. Brendan McMahan, Felix X. Yu, Peter Richt \\` arik, Ananda Theertha Suresh, ´ and Dave Bacon. Federated learning: Strategies for improving communication efficiency. arXiv preprint arXiv:1610.05492, 2016.   \n[39] Lihua Lei and Michael Jordan. Less than a single pass: Stochastically controlled stochastic gradient. In AISTATS, pages 148–156, 2017.   \n[40] Tian Li, Anit Kumar Sahu, Maziar Sanjabi, Manzil Zaheer, Ameet Talwalkar, and Virginia Smith. On the convergence of federated optimization in heterogeneous networks. arXiv preprint arXiv:1812.06127, 2018.   \n[41] Tian Li, Maziar Sanjabi, and Virginia Smith. Fair resource allocation in federated learning. arXiv preprint arXiv:1905.10497, 2019.   \n[42] Liyuan Liu, Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Jiawei Han. On the variance of the adaptive learning rate and beyond. arXiv preprint arXiv:1908.03265, 2019.   \n[43] Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. ¨ Communication-efficient learning of deep networks from decentralized data. In Proceedings of AISTATS, pages 1273–1282, 2017.   \n[44] Mehryar Mohri, Gary Sivek, and Ananda Theertha Suresh. Agnostic federated learning. arXiv preprint arXiv:1902.00146, 2019.   \n[45] Yurii Nesterov. Lectures on convex optimization, volume 137. Springer, 2018.   \n[46] Lam M. Nguyen, Jie Liu, Katya Scheinberg, and Martin Taka´c. Stochastic recursive gradient ˇ algorithm for nonconvex optimization. arXiv preprint arXiv:1705.07261, 2017.   \n[47] Kumar Kshitij Patel and Aymeric Dieuleveut. Communication trade-offs for synchronized distributed SGD with large step size. In 33rd Conference on Neural Information Processing Systems (NeurIPS), 2019.   \n[48] Krishna Pillutla, Sham M Kakade, and Zaid Harchaoui. Robust aggregation for federated learning. arXiv preprint arXiv:1912.13445, 2019.   \n[49] Sashank Reddi, Zachary Charles, Manzil Zaheer, Zachary Garrett, Keith Rush, Jakub Konecnˇ y,\\` Sanjiv Kumar, and H Brendan McMahan. Adaptive federated optimization. arXiv preprint arXiv:2003.00295, 2020.   \n[50] Sashank J Reddi, Satyen Kale, and Sanjiv Kumar. On the convergence of adam and beyond. International Conference on Learning Representations (ICLR), 2018.   \n[51] Sashank J. Reddi, Jakub Konecnˇ y, Peter Richt \\` arik, Barnab ´ as P ´ ocz ´ os, and Alex Smola. Aide: ´ Fast and communication efficient distributed optimization. arXiv preprint arXiv:1608.06879, 2016.   \n[52] Jae Hun Ro, Ananda Theertha Suresh, and Ke Wu. FedJAX: Federated learning simulation with JAX, 2020.   \n[53] Jae Hun Ro, Ananda Theertha Suresh, and Ke Wu. Fedjax: Federated learning simulation with jax. arXiv preprint arXiv:2108.02117, 2021.   \n[54] Ohad Shamir, Nati Srebro, and Tong Zhang. Communication-efficient distributed optimization using an approximate newton-type method. In International conference on machine learning, pages 1000–1008, 2014.   \n[55] Noam Shazeer and Mitchell Stern. Adafactor: Adaptive learning rates with sublinear memory cost. In International Conference on Machine Learning, pages 4596–4604. PMLR, 2018.   \n[56] Sebastian U. Stich. Local SGD converges fast and communicates little. International Conference on Learning Representations (ICLR), 2019.   \n[57] Sebastian U. Stich and Sai Praneeth Karimireddy. The error-feedback framework: Better rates for SGD with delayed gradients and compressed communication. arXiv preprint arXiv:1909.05350, 2019.   \n[58] Ananda Theertha Suresh, Felix X. Yu, Sanjiv Kumar, and H. Brendan McMahan. Distributed mean estimation with limited communication. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 3329–3337. JMLR. org, 2017.   \n[59] Ilya Sutskever, James Martens, George Dahl, and Geoffrey Hinton. On the importance of initialization and momentum in deep learning. In International conference on machine learning, pages 1139–1147, 2013.   \n[60] TFF. Tensorflow federated datasets. https: // www. tensorflow. org/ federated/ api_ docs/ python/ tff/ simulation/ datasets , 2020.   \n[61] Om Thakkar, Swaroop Ramaswamy, Rajiv Mathews, and Franc¸oise Beaufays. Understanding unintended memorization in federated learning. arXiv preprint arXiv:2006.07490, 2020.   \n[62] Quoc Tran-Dinh, Nhan H. Pham, Dzung T. Phan, and Lam M. Nguyen. Hybrid stochastic gradient descent algorithms for stochastic nonconvex optimization. arXiv preprint arXiv:1905.05920, 2019.   \n[63] Sharan Vaswani, Francis Bach, and Mark Schmidt. Fast and faster convergence of SGD for over-parameterized models and an accelerated perceptron. arXiv preprint arXiv:1810.07288, 2018.   \n[64] Thijs Vogels, Sai Praneeth Karimireddy, and Martin Jaggi. Powersgd: Practical low-rank gradient compression for distributed optimization. In Advances in Neural Information Processing Systems (NeurIPS), 2019.   \n[65] Hongyi Wang, Kartik Sreenivasan, Shashank Rajput, Harit Vishwakarma, Saurabh Agarwal, Jy-yong Sohn, Kangwook Lee, and Dimitris Papailiopoulos. Attack of the tails: Yes, you really can backdoor federated learning. arXiv preprint arXiv:2007.05084, 2020.   \n[66] Jianyu Wang, Qinghua Liu, Hao Liang, Gauri Joshi, and H Vincent Poor. Tackling the objective inconsistency problem in heterogeneous federated optimization. arXiv preprint arXiv:2007.07481, 2020.   \n[67] Jianyu Wang, Vinayak Tantia, Nicolas Ballas, and Michael Rabbat. SlowMo: Improving communication-efficient distributed sgd with slow momentum. International Conference on Learning Representations (ICLR), 2020.   \n[68] Shiqiang Wang, Tiffany Tuor, Theodoros Salonidis, Kin K. Leung, Christian Makaya, Ting He, and Kevin Chan. Adaptive federated learning in resource constrained edge computing systems. IEEE Journal on Selected Areas in Communications, 37(6):1205–1221, 2019.   \n[69] Blake Woodworth, Kumar Kshitij Patel, and Nathan Srebro. Minibatch vs local SGD for heterogeneous distributed learning. arXiv preprint arXiv:2006.04735, 2020.   \n[70] Blake Woodworth, Kumar Kshitij Patel, Sebastian U Stich, Zhen Dai, Brian Bullins, H Brendan McMahan, Ohad Shamir, and Nathan Srebro. Is local SGD better than minibatch SGD? In 37th International Conference on Machine Learning (ICML), 2020.   \n[71] Yang You, Igor Gitman, and Boris Ginsburg. Large batch training of convolutional networks. arXiv preprint arXiv:1708.03888, 2017.   \n[72] Yang You, Jing Li, Sashank Reddi, Jonathan Hseu, Sanjiv Kumar, Srinadh Bhojanapalli, Xiaodan Song, James Demmel, Kurt Keutzer, and Cho-Jui Hsieh. Large batch optimization for deep learning: Training bert in 76 minutes. In International Conference on Learning Representations, 2019.   \n[73] Hao Yu, Rong Jin, and Sen Yang. On the linear speedup analysis of communication efficient momentum sgd for distributed non-convex optimization. arXiv preprint arXiv:1905.03817, 2019.   \n[74] Hao Yu, Sen Yang, and Shenghuo Zhu. Parallel restarted SGD with faster convergence and less communication: Demystifying why model averaging works for deep learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 5693–5700, 2019.   \n[75] Manzil Zaheer, Sashank Reddi, Devendra Sachan, Satyen Kale, and Sanjiv Kumar. Adaptive methods for nonconvex optimization. In Advances in neural information processing systems, pages 9793–9803, 2018.   \n[76] Jingzhao Zhang, Tianxing He, Suvrit Sra, and Ali Jadbabaie. Why gradient clipping accelerates training: A theoretical justification for adaptivity. In International Conference on Learning Representations, 2020.   \n[77] Jingzhao Zhang, Sai Praneeth Karimireddy, Andreas Veit, Seungyeon Kim, Sashank J Reddi, Sanjiv Kumar, and Suvrit Sra. Why ADAM beats SGD for attention models. arXiv preprint arXiv:1912.03194, 2019.   \n[78] Martin Zinkevich, Markus Weimer, Lihong Li, and Alex J Smola. Parallelized stochastic gradient descent. In Advances in neural information processing systems, pages 2595–2603, 2010. ",
+        "bbox": [
+            179,
+            506,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            61,
+            828,
+            921
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            168,
+            68,
+            826,
+            917
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            34,
+            826,
+            920
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            26,
+            826,
+            843
+        ],
+        "page_idx": 13
+    }
+]

parse/train/H1uR4GZRZ/H1uR4GZRZ.md

@@ -0,0 +1,314 @@
+# STOCHASTIC ACTIVATION PRUNING FOR ROBUST ADVERSARIAL DEFENSE
+
+Guneet S. Dhillon1,2, Kamyar Azizzadenesheli3, Zachary C. Lipton $^ { 1 , 4 }$ ,   
+Jeremy Bernstein1,5, Jean Kossaifi1,6, Aran Khanna1, Anima Anandkumar1,5   
+1Amazon AI, 2UT Austin, 3UC Irvine, 4CMU, 5Caltech, 6Imperial College London   
+guneetdhillon@utexas.edu, kazizzad@uci.edu, zlipton@cmu.edu, bernstein@caltech.edu, jean.kossaifi@imperial.ac.uk, aran@arankhanna.com, anima@amazon.com
+
+# ABSTRACT
+
+Neural networks are known to be vulnerable to adversarial examples. Carefully chosen perturbations to real images, while imperceptible to humans, induce misclassification and threaten the reliability of deep learning systems in the wild. To guard against adversarial examples, we take inspiration from game theory and cast the problem as a minimax zero-sum game between the adversary and the model. In general, for such games, the optimal strategy for both players requires a stochastic policy, also known as a mixed strategy. In this light, we propose Stochastic Activation Pruning (SAP), a mixed strategy for adversarial defense. SAP prunes a random subset of activations (preferentially pruning those with smaller magnitude) and scales up the survivors to compensate. We can apply SAP to pretrained networks, including adversarially trained models, without fine-tuning, providing robustness against adversarial examples. Experiments demonstrate that SAP confers robustness against attacks, increasing accuracy and preserving calibration.
+
+# 1 INTRODUCTION
+
+While deep neural networks have emerged as dominant tools for supervised learning problems, they remain vulnerable to adversarial examples (Szegedy et al., 2013). Small, carefully chosen perturbations to input data can induce misclassification with high probability. In the image domain, even perturbations so small as to be imperceptible to humans can fool powerful convolutional neural networks (Szegedy et al., 2013; Goodfellow et al., 2014). This fragility presents an obstacle to using machine learning in the wild. For example, a vision system vulnerable to adversarial examples might be fundamentally unsuitable for a computer security application. Even if a vision system is not explicitly used for security, these weaknesses might be critical. Moreover, these problems seem unnecessary. If these perturbations are not perceptible to people, why should they fool a machine?
+
+Since this problem was first identified, a rapid succession of papers have proposed various techniques both for generating and for guarding against adversarial attacks. Goodfellow et al. (2014) introduced a simple method for quickly producing adversarial examples called the fast gradient sign method (FGSM). To produce an adversarial example using FGSM, we update the inputs by taking one step in the direction of the sign of the gradient of the loss with respect to the input.
+
+To defend against adversarial examples some papers propose training the neural network on adversarial examples themselves, either using the same model (Goodfellow et al., 2014; Madry et al., 2017), or using an ensemble of models (Tramèr et al., 2017a). Taking a different approach, Nayebi & Ganguli (2017) draws inspiration from biological systems. They propose that to harden neural networks against adversarial examples, one should learn flat, compressed representations that are sensitive to a minimal number of input dimensions.
+
+This paper introduces Stochastic Activation Pruning (SAP), a method for guarding pretrained networks against adversarial examples. During the forward pass, we stochastically prune a subset of the activations in each layer, preferentially retaining activations with larger magnitudes. Following the pruning, we scale up the surviving activations to normalize the dynamic range of the inputs to the subsequent layer. Unlike other adversarial defense methods, our method can be applied post-hoc to pretrained networks and requires no additional fine-tuning.
+
+# 2 PRELIMINARIES
+
+We denote an $n$ -layered neural network $h : \mathcal { X }  Y$ as a chain of functions $h = h ^ { n } \circ h ^ { n - 1 } \circ . . . \circ h ^ { 1 }$ , where each $h ^ { i }$ consists of a linear transformation $W ^ { i }$ followed by a non-linearity $\phi ^ { i }$ . Given a set of nonlinearities and weight matrices, a neural network provides a nonlinear mapping from inputs $x \in \mathcal { X }$ to outputs $\hat { y } \in \mathcal { V }$ , i.e.
+
+$$
+\hat { y } : = h ( x ) = \phi ^ { n } ( W ^ { n } \phi ^ { n - 1 } ( W ^ { n - 1 } \phi ^ { n - 2 } ( . . . \phi ^ { 1 } ( W ^ { 1 } x ) ) ) ) .
+$$
+
+In supervised classification and regression problems, we are given a data set $\mathcal { D }$ of pairs $( x , y )$ , where each pair is drawn from an unknown joint distribution. For the classification problems, $y$ is a categorical random variable, and for regression, $y$ is a real-valued vector. Conditioned on a given dataset, network architecture, and a loss function such as cross entropy, a learning algorithm, e.g. stochastic gradient descent, learns parameters $\theta : = \{ W ^ { i } \} _ { i = 1 } ^ { n }$ in order to minimize the loss. We denote $J ( \theta , x , y )$ as the loss of a learned network, parameterized by $\theta$ , on a pair of $( x , y )$ . To simplify notation, we focus on classification problems, although our methods are broadly applicable.
+
+Consider an input $x$ that is correctly classified by the model $h$ . An adversary seeks to apply a small additive perturbation, $\Delta x$ , such that $h ( x ) \neq h ( x + \Delta x )$ , subject to the constraint that the perturbation is imperceptible to a human. For perturbations applied to images, the $l _ { \infty }$ -norm is considered a better measure of human perceptibility than the more familiar $l _ { 2 }$ norm Goodfellow et al. (2014). Throughout this paper, we assume that the manipulative power of the adversary, the perturbation $\Delta x$ , is of bounded norm $\| \Delta x \| _ { \infty } \leq \lambda$ . Given a classifier, one common way to generate an adversarial example is to perturb the input in the direction that increases the cross-entropy loss. This is equivalent to minimizing the probability assigned to the true label. Given the neural network $h$ , network parameters $\theta$ , input data $x$ , and corresponding true output $y$ , an adversary could create a perturbation $\Delta x$ as follows
+
+$$
+\Delta x = \arg \operatorname* { m a x } _ { \| r \| \infty } J ( \theta , x + r , y ) ,
+$$
+
+Due to nonlinearities in the underlying neural network, and therefore of the objective function $J$ , the optimization Eq. 1, in general, can be a non-convex problem. Following Madry et al. (2017); Goodfellow et al. (2014), we use the first order approximation of the loss function
+
+$$
+\Delta x = \arg \operatorname* { m a x } _ { \| r \| _ { \infty } \leq \lambda } [ J ( \theta , x , y ) + r ^ { \top } \mathcal { T } ( \theta , x , y ) ] , \qquad \mathrm { w h e r e ~ } \mathcal { I } = \nabla _ { x } J .
+$$
+
+The first term in the optimization is not a function of the adversary perturbation, therefore reduces to
+
+$$
+\Delta x = \arg \operatorname* { m a x } _ { \| r \| _ { \infty } \leq \lambda } { r ^ { \top } \mathcal { I } ( \theta , x , y ) } .
+$$
+
+An adversary chooses $r$ to be in the direction of sign of $\mathcal { I } ( \theta , x , y )$ , i.e. $\Delta x = \lambda \cdot \mathrm { s i g n } ( \mathcal { I } ( \theta , x , y ) )$ . This is the FGSM technique due to Goodfellow et al. (2014). Note that FGSM requires an adversary to access the model in order to compute the gradient.
+
+# 3 STOCHASTIC ACTIVATION PRUNING
+
+Consider the defense problem from a game-theoretic perspective (Osborne & Rubinstein, 1994). The adversary designs a policy in order to maximize the defender’s loss, while knowing the defenders policy. At the same time defender aims to come up with a strategy to minimize the maximized loss. Therefore, we can rewrite Eq. 1 as follows
+
+$$
+\pi ^ { * } , \rho ^ { * } : = \arg \operatorname* { m i n } _ { \pi } \operatorname* { m a x } _ { \rho } \mathbb { E } _ { p \sim \pi , r \sim \rho } \left[ J ( M _ { p } ( \theta ) , x + r , y ) \right] ,
+$$
+
+where $\rho$ is the adversary’s policy, which provides $r \sim \rho$ in the space of bounded (allowed) perturbations (for any $r$ in range of $\rho$ , $\| r \| _ { \infty } \leq \bar { \lambda } )$ and $\pi$ is the defenders policy which provides $p \sim \pi$ , an instantiation of its policy. The adversary’s goal is to maximize the loss of the defender by perturbing
+
+# Algorithm 1 Stochastic Activation Pruning (SAP)
+
+<table><tr><td>1:</td><td colspan="3">Input: input datum x, neural network with n layers, with ith layer having weight matrix Wi, non-linearity $i and number of samples to be drawn r𝑖 .</td></tr><tr><td>2:</td><td>h←x</td><td></td><td></td></tr><tr><td>3:</td><td>for each layeri do</td><td></td><td></td></tr><tr><td>h² ←²(Wihi-1)</td><td></td><td></td><td>&gt;activation vector for layer i with dimension ai</td></tr><tr><td>4: 5:</td><td>p← (h²)j</td><td>∀j ∈{1,...,a²}</td><td>&gt;activations normalized on to the simplex</td></tr><tr><td>6:</td><td>s←0</td><td>∑=1(h）1</td><td>&gt; set of indices not to be pruned</td></tr><tr><td>7:</td><td>repeat ri times</td><td></td><td>&gt; the activations have ri chances of being kept</td></tr><tr><td>8:</td><td></td><td>Draw s ~ categorical(p)</td><td>draw an index to be kept</td></tr><tr><td>9:</td><td>S←SU{s}</td><td></td><td>add index s to the keep set</td></tr><tr><td>10:</td><td>for each j  Sdo</td><td></td><td></td></tr><tr><td>11:</td><td>(h²)←0</td><td></td><td> prune the activations not in S</td></tr><tr><td>12:</td><td>for each j ∈ S do</td><td></td><td></td></tr><tr><td>13:</td><td>(h²);← (h²)j</td><td></td><td>&gt; scale up the activations in S</td></tr><tr><td></td><td>1-(1-p）m</td><td></td><td></td></tr><tr><td></td><td>14: return hn</td><td></td><td></td></tr></table>
+
+the input under a strategy $\rho$ and the defender’s goal is to minimize the loss by changing model parameters $\theta$ to $M _ { p } ( \theta )$ under strategy $\pi$ . The optimization problem in Eq. 2 is a minimax zero-sum game between the adversary and defender where the optimal strategies $( \pi ^ { * } , \rho ^ { * } )$ , in general, are mixed Nash equilibrium, i.e. stochastic policies.
+
+Intuitively, the idea of SAP is to stochastically drop out nodes in each layer during forward propagation. We retain nodes with probabilities proportional to the magnitude of their activation and scale up the surviving nodes to preserve the dynamic range of the activations in each layer. Empirically, the approach preserves the accuracy of the original model. Notably, the method can be applied post-hoc to already-trained models.
+
+Formally, assume a given pretrained model, with activation layers (ReLU, Sigmoid, etc.) and input pair of $( x , y )$ . For each of those layers, SAP converts the activation map to a multinomial distribution, choosing each activation with a probability proportional to its absolute value. In other words, we obtain the multinomial distribution of each activation layer with $L _ { 1 }$ normalization of their absolute values onto a $L _ { 1 }$ -ball simplex. Given the $i$ ’th layer activation map, $h ^ { i } \in \mathbb { R } ^ { a ^ { i } }$ , the probability of sampling the $j ^ { ; }$ ’th activation with value $( h ^ { i } ) _ { j }$ is given by
+
+$$
+p _ { j } ^ { i } = \frac { | ( h ^ { i } ) _ { j } | } { \sum _ { k = 1 } ^ { a ^ { i } } | ( h ^ { i } ) _ { k } | } .
+$$
+
+We draw random samples with replacement from the activation map given the probability distribution described above. This makes it convenient to determine whether an activation would be sampled at all. If an activation is sampled, we scale it up by the inverse of the probability of sampling it over all the draws. If not, we set the activation to 0. In this way, SAP preserves inverse propensity scoring of each activation. Under an instance $p$ of policy $\pi$ , we draw $r _ { p } ^ { i }$ samples with replacement from this multinomial distribution. The new activation map, $M _ { p } ( h ^ { i } )$ is given by
+
+$$
+M _ { p } ( h ^ { i } ) = h ^ { i } \odot m _ { p } ^ { i } , \qquad ( m _ { p } ^ { i } ) _ { j } = \frac { \mathbb { I } ( ( h ^ { i } ) _ { j } ) } { 1 - ( 1 - p _ { j } ^ { i } ) ^ { r _ { p } ^ { i } } } ,
+$$
+
+where $\mathbb { I } ( ( h ^ { i } ) _ { j } )$ is the indicator function that returns 1 if $( h ^ { i } ) _ { j }$ was sampled at least once, and 0 otherwise. The algorithm is described in Algorithm 1. In this way, the model parameters are changed from $\theta$ to $M _ { p } ( \theta )$ , for instance $p$ under policy $\pi$ , while the reweighting $1 - ( 1 - p _ { j } ^ { i } ) ^ { r _ { p } ^ { i } }$ preserves $\mathbb { E } _ { p \sim \pi } [ M _ { p } ( h ^ { i } ) _ { j } ] = ( h ^ { i } ) _ { j }$ . If the model was linear, the proposed pruning method would behave the same way as the original model in expectation. In practice, we find that even with the non-linearities in deep neural networks, for sufficiently many examples, SAP performs similarly to the un-pruned model. This guides our decision to apply SAP to pretrained models without performing fine-tuning.
+
+# 3.1 ADVANTAGE AGAINST ADVERSARIAL ATTACK
+
+We attempt to explain the advantages of SAP under the assumption that we are applying it to a pre-trained model that achieves high generalization accuracy. For instance $p$ under policy $\pi$ , if the number of samples drawn for each layer $i$ , $r _ { p } ^ { i }$ , is large, then fewer parameters of the neural network are pruned, and the scaling factor gets closer to 1. Under this scenario, the stochastically pruned model performs almost identically to the original model. The stochasticity is not advantageous in this case, but there is no loss in accuracy in the pruned model as compared to the original model.
+
+On the other hand, with fewer samples in each layer, $r _ { p } ^ { i }$ , a large number of parameters of the neural network are pruned. Under this scenario, the SAP model’s accuracy will drop compared to the original model’s accuracy. But this model is stochastic and has more freedom to deceive the adversary. So the advantage of SAP comes if we can balance the number of samples drawn in a way that negligibly impacts accuracy but still confers robustness against adversarial attacks.
+
+SAP is similar to the dropout technique due to Srivastava et al. (2014). However, there is a crucial difference: SAP is more likely to sample activations that are high in absolute value, whereas dropout samples each activation with the same probability. Because of this difference, SAP, unlike dropout, can be applied post-hoc to pretrained models without significantly decreasing the accuracy of the model. Experiments comparing SAP and dropout are included in section 4. Interestingly, dropout confers little advantage over the baseline. We suspect that the reason for this is that the dropout training procedure encourages all possible dropout masks to result in similar mappings.
+
+# 3.2 ADVERSARIAL ATTACK ON SAP
+
+If the adversary knows that our defense policy is to apply SAP, it might try to calculate the best strategy against the SAP model. Given the neural network $h$ , input data $x$ , corresponding true output $y$ , a policy $\rho$ over the allowed perturbations, and a policy $\pi$ over the model parameters that come from SAP (this result holds true for any stochastic policy chosen over the model parameters), the adversary determines the optimal policy $\rho ^ { * }$
+
+$$
+\rho ^ { * } = \arg \operatorname* { m a x } _ { \rho } \mathbb { E } _ { p \sim \pi , r \sim \rho } [ J ( M _ { p } ( \theta ) , x + r , y ) ] .
+$$
+
+Therefore, using the result from section 2, the adversary determines the perturbation $\Delta x$ as follows;
+
+$$
+\Delta x = \arg \operatorname* { m a x } _ { r } r ^ { \top } \mathbb { E } _ { p \sim \pi } [ \mathcal { I } ( M _ { p } ( \theta ) , x , y ) ] .
+$$
+
+To maximize the term, the adversary will set $r$ to be in the direction of sign of $\mathbb { E } _ { p \sim \pi } [ \mathcal { I } ( M _ { p } ( \theta ) , x , y ) ]$ . Analytically computing $\mathbb { E } _ { p \sim \pi } [ \mathcal { T } ( M _ { p } ( \theta ) , x , y ) ]$ is not feasible. However, the adversary can use Monte Carlo (MC) sampling to estimate the expectation as $\mathcal { \widetilde { I } } ( M _ { p } ( \theta ) , x , y )$ . Then, using FGSM, $\Delta x = \lambda \cdot \mathrm { s i g n } ( \widetilde { \mathcal { I } } ( M _ { p } ( \theta ) , x , y ) )$ .
+
+# 4 EXPERIMENTS
+
+Our experiments to evaluate SAP address two tasks: image classification and reinforcement learning. We apply the method to the $R e L U$ activation maps at each layer of the pretrained neural networks. To create adversarial examples in our evaluation, we use FGSM, $\Delta x = \lambda \cdot \mathrm { s i g n } ( \mathcal { I } ( M _ { p } ( \theta ) , x , y ) )$ . For stochastic models, the adversary estimates $\mathcal { I } ( M _ { p } ( \theta ) , x , y )$ using MC sampling unless otherwise mentioned. All perturbations are applied to the pixel values of images, which normally take values in the range 0-255. So the fraction of perturbation with respect to the data’s dynamic range would be λ256 . To ensure that all images are valid, even following perturbation, we clip the resulting pixel values so that they remain within the range $[ 0 , 2 5 5 ]$ . In all plots, we consider perturbations of the following magnitudes $\lambda = \{ 0 , 1 , 2 , 4 , 8 , 1 6 , 3 \dot { 2 } , 6 4 \}$ .1
+
+To evaluate models in the image classification domain, we look at two aspects: the model accuracy for varying values of $\lambda$ , and the calibration of the models (Guo et al., 2017). Calibration of a model is the relation between the confidence level of the model’s output and its accuracy. A linear calibration is ideal, as it suggests that the accuracy of the model is proportional to the confidence level of its output. To evaluate models in the reinforcement learning domain, we look at the average score that each model achieves on the games played, for varying values of $\lambda$ . The higher the score, the better is the model’s performance. Because the units of reward are arbitrary, we report results in terms of the the relative percent change in rewards. In both cases, the output of stochastic models are computed as an average over multiple forward passes.
+
+![](images/2cfc5effd361d7be95015576fa66a9f8a0ef5ab0cf3e5cfe5cdb2b6e5fea6796.jpg)  
+Figure 1: Accuracy plots of a variety of attacks against dense model and SAP models with different perturbation strengths, $\lambda$ . For the SAP $\tau \%$ models, $\tau$ denotes the percentages of samples drawn from the multinomial distribution, at each layer. $( a )$ SAP models tested against random perturbation. $( b )$ SAP models tested against the FGSM attack, using MC sampling. $( c )$ SAP-100 tested against an iterative adversarial attack, using MC sampling (legend shows defender vs. adversary). It is worth restating that obtaining the iterative attack of SAP models is much more expensive and noisier than the iterative attack of dense models.
+
+# 4.1 ADVERSARIAL ATTACKS IN IMAGE CLASSIFICATION
+
+The CIFAR-10 dataset (Krizhevsky & Hinton, 2009) was used for the image classification domain. We trained a ResNet-20 model (He et al., 2016) using SGD, with minibatches of size 512, momentum of 0.9, weight decay of 0.0001, and a learning rate of 0.5 for the first 100 epochs, then 0.05 for the next 30 epochs, and then 0.005 for the next 20 epochs. This achieved an accuracy of $8 9 . 8 \%$ with cross-entropy loss and $R e L U$ non-linearity. For all the figures in this section, we refer to this model as the dense model. The accuracy of the dense model degrades quickly with $\lambda$ . For $\lambda = 1$ , the accuracy drops down to $6 6 . 3 \%$ , and for $\lambda = 2$ it is $5 6 . 4 \%$ . These are small (hardly perceptible) perturbations in the input images, but the dense model’s accuracy decreases significantly.
+
+# 4.1.1 STOCHASTIC ACTIVATION PRUNING (SAP)
+
+We apply SAP to the dense model. For each activation map $h ^ { i } \in \mathbb { R } ^ { a ^ { i } }$ , we pick $k \%$ of $a ^ { i }$ activations to keep. Since activations are sampled with replacement, $k$ can be more than 100. We will refer to $k$ as the percentage of samples drawn. Fig. 1a plots performance of SAP models against examples perturbed with random noise. Perturbations of size $\lambda = 6 4$ are readily perceptible and push all models under consideration to near-random outputs, so we focus our attention on smaller values of $\lambda$ Fig. 1b plots performance of these models against adversarial examples. With many samples drawn, SAP converges to the dense model. With few samples drawn, accuracy diminishes for $\lambda = 0$ , but is higher for $\lambda \neq 0$ . The plot explains this balance well. We achieve the best performance with $\sim 1 0 0 \%$ samples picked. We will now only look at SAP $1 0 0 \%$ (SAP-100). Against adversarial examples, with $\lambda = 1$ , 2 and 4, we observe a $1 2 . 2 \%$ , $1 6 . 3 \%$ and $1 2 . 8 \%$ absolute increase in accuracy respectively. However, for $\lambda = 0$ , we observe a $6 . 5 \%$ absolute decrease in accuracy. For $\lambda = 1 6$ again, there is a $5 . 2 \%$ absolute decrease in accuracy.
+
+# 4.1.2 DROPOUT (DRO)
+
+Dropout, a technique due to Srivastava et al. (2014), was also tested to compare with SAP. Similar to the SAP setting, this method was added to the $R e L U$ activation maps of the dense model. We see that low dropout rate perform similar to the dense model for small $\lambda$ values, but its accuracy starts decreasing very quickly for higher $\lambda$ values (Fig. 2a). We also trained ResNet-20 models, similar to the dense model, but with different dropout rates. This time, the models were trained for 250 epochs, with an initial learning rate of 0.5, reduced by a factor of 0.1 after 100, 150, 190 and 220 epochs. These models were tested against adversarial examples with and without dropout during validation (Figs. 2b and 2c respectively). The models do similar to the dense model, but do not provide additional robustness.
+
+![](images/cf5a09a72eea72ce85ab14309a4b105445dc4521fa24409190d89249a7f01dfb.jpg)  
+Figure 2: Robustness of dropout models, with different rates of dropout (denoted in the legends), against adversarial attacks, using MC sampling, with a variety of perturbation strengths, $\lambda$ : $( a )$ dropout is applied on the pre-trained models during the validations; $( b )$ the models are trained using dropout, and dropout is applied during the validations; $( c )$ the models are trained using dropout, but dropout is not applied during the validations.
+
+# 4.1.3 ADVERSARIAL TRAINING (ADV)
+
+Adversarial training (Goodfellow et al., 2014) has emerged a standard method for defending against adversarial examples. It has been adopted by Madry et al. (2017); Tramèr et al. (2017a) to maintain high accuracy levels even for large $\lambda$ values. We trained a ResNet-20 model, similar to the dense model, with an initial learning rate of 0.5, which was halved every 10 epochs, for a total of 100 epochs. It was trained on a dataset consisting of $8 0 \%$ un-perturbed data and $2 0 \%$ adversarially perturbed data, generated on the model from the previous epoch, with $\lambda = 2$ . This achieved an accuracy of $7 5 . 0 \%$ on the un-perturbed validation set. Note that the model capacity was not changed. When tested against adversarial examples, the accuracy dropped to $7 2 . 9 \%$ , $7 0 . 9 \%$ and $6 7 . 5 \%$ for $\lambda = 1 , 2$ and 4 respectively. We ran SAP-100 on the ADV model (referred to as $\mathrm { \ A D V { + } S A P { - } 1 0 0 }$ ). The accuracy in the no perturbation case was $7 4 . 1 \%$ . For adversarial examples, both models act similar to each other for small values of $\lambda$ . But for $\lambda = 1 6$ and 32, ADV $^ +$ SAP-100 gets a higher accuracy than ADV by an absolute increase of $7 . 8 \%$ and $7 . 9 \%$ respectively.
+
+We compare the accuracy- $\lambda$ plot for dense, SAP-100, ADV and $\mathrm { \ A D V + S A P - 1 0 0 }$ models. This is illustrated in Fig. 3 For smaller values of $\lambda$ , SAP-100 achieves high accuracy. As $\lambda$ gets larger, ADV+SAP-100 performs better than all the other models. We also compare the calibration plots for these models, in Fig. 4. The dense model is not linear for any $\lambda \neq 0$ . The other models are well calibrated (close to linear), and behave similar to each other for $\lambda \leq 4$ . For higher values of $\lambda$ , we see that ADV $^ +$ SAP-100 is the closest to a linearly calibrated model.
+
+# 4.2 ADVERSARIAL ATTACKS IN DEEP REINFORCEMENT LEARNING (RL)
+
+Previously, (Behzadan & Munir, 2017; Huang et al., 2017; Kos & Song, 2017) have shown that the reinforcement learning agents can also be easily manipulated by adversarial examples. The RL agent learns the long term value $Q ( a , s )$ of each state-action pair $( s , a )$ through interaction with an environment, where given a state $s$ , the optimal action is ar $\operatorname { g m a x } _ { a } Q ( a , s )$ . A regression based algorithm, Deep Q-Network (DQN)(Mnih et al., 2015) and an improved variant, Double DQN (DDQN) have been proposed for the popular Atari games (Bellemare et al., 2013) as benchmarks. We deploy DDQN algorithm and train an RL agent in variety of different Atari game settings.
+
+Similar to the image classification experiments, we tested SAP on a pretrained model (the model is described in the Appendix section A), by applying the method on the $R e L U$ activation maps. SAP-100 was used for these experiments. Table 1 specifies the relative percentage increase in rewards of SAP-100 as compared to the original model. For all the games, we observe a drop in performance for the no perturbation case. But for $\lambda \neq 0$ , the relative increase in rewards is positive (except for $\lambda = 1$ in the BattleZone game), and is very high in some cases $3 4 2 5 . 9 \%$ for $\lambda = 1$ for the Bowling game).
+
+![](images/41f08661db51f681f834b8eeee51c4349cab7a1712609127c17efa7361b51ea1.jpg)  
+Figure 3: Accuracy plots of the dense, SAP-100, ADV and ADV $^ +$ SAP-100 models, against adversarial attacks, using MC sampling, with a variety of perturbation strengths, $\lambda$ .
+
+![](images/cd82a04170fe1db66bd326f0afd399ef0c7a8af036637d6956b7fd17149af915.jpg)  
+Figure 4: Calibration plots of the dense, SAP-100, ADV and $\mathrm { A D V + S A P - 1 0 0 }$ models, against adversarial attacks, using MC sampling, with a variety of different perturbation strengths, $\lambda$ . These plots show the relation between the confidence level of the model’s output and its accuracy.
+
+# 4.3 ADDITIONAL BASELINES
+
+In addition to experimenting with SAP, dropout, and adversarial training, we conducted extensive experiments with other methods for introducing stochasticity into a neural network. These techniques included 0-mean Gaussian noise added to weights (RNW), 1-mean multiplicative Gaussian noise for the weights (RSW), and corresponding additive (RNA) and multiplicative (RSA) noise added to
+
+Table 1: Relative percentage increase in rewards gained for SAP-100 compared to original model while playing different Atari games.
+
+<table><tr><td>入</td><td>Assault</td><td>Asterix</td><td>BankHeist</td><td>BattleZone</td><td>BeamRider</td><td>Bowling</td></tr><tr><td>0</td><td>-12.2%</td><td>-33.4%</td><td>-59.2%</td><td>-65.8%</td><td>-15.8%</td><td>-4.5%</td></tr><tr><td>1</td><td>10.4%</td><td>13.3%</td><td>131.7%</td><td>-22.0%</td><td>164.5%</td><td>3425.9%</td></tr><tr><td>2</td><td>9.8%</td><td>20.8%</td><td>204.8%</td><td>110.1%</td><td>92.3%</td><td></td></tr><tr><td>4</td><td>12.4%</td><td>14.0%</td><td>1760.0%</td><td>202.6%</td><td></td><td></td></tr><tr><td>8</td><td>16.6%</td><td>7.4%</td><td>60.9%</td><td>134.8%</td><td></td><td></td></tr></table>
+
+![](images/11be80ac9647eec18d0188fde068ff458ea586f8c9047924aed06548372995fa.jpg)  
+Figure 5: Robustness of different pruning and noisifying strategies against their respective adversarial attacks (MC sampling used to estimate gradients of stochastic models).
+
+the activations. We describe each method in detail in Appendix B. Each of these models performs worse than the dense baseline at most levels of perturbation and none matches the performance of SAP. Precisely why SAP works while other methods introducing stochasticity do not, remains an open question that we continue to explore in future work.
+
+# 4.4 SAP ATTACKS WITH VARYING NUMBERS OF MC SAMPLES
+
+In the previous experiments the SAP adversary used $1 0 0 ~ \mathrm { M C }$ samples to estimate the gradient. Additionally, we compared the performance of SAP-100 against various attacks, these include the standard attack calculated based on the dense model and those generated on SAP-100 by estimating the gradient with various numbers of MC samples. We see that if the adversary uses the dense model to generate adversarial examples, SAP-100 model’s accuracy decreases. Additionally, if the adversary uses the SAP-100 model to generate adversarial examples, greater numbers of MC samples lower the accuracy more. Still, even with $1 0 0 0 \mathbf { M C }$ samples, for low amounts of perturbation ( $\lambda = 1$ and 2), SAP-100 retains higher accuracy than the dense model.
+
+Computing a single backward pass of the SAP-100 model for 512 examples takes $\sim 2 0$ seconds on 8 GPUs. Using 100 and $1 0 0 0 \mathbf { M C }$ samples would take $\sim 0 . 6$ and $\sim 6$ hours respectively.
+
+# 4.5 ITERATIVE ADVERSARIAL ATTACK
+
+A more sophisticated technique for producing adversarial perturbations (than FGSM) is to apply multiple and smaller updates to the input in the direction of the local sign-gradients. This can be done by taking small steps of size $k \leq \lambda$ in the direction of the sign-gradient at the updated point and
+
+![](images/2a4e319afc1606eccb7edab10c6f47fd3354fcf721ff055794c029e2134e683f.jpg)  
+Figure 6: Accuracy plots of adversarial attacks, with different perturbation strengths, $\lambda$ . The legend shows defender vs. adversary models (used for gradient computation), and the number of MC samples used to estimate the gradient.
+
+repeating the procedure $\lceil \frac { \lambda } { k } \rceil$ times (Kurakin et al., 2016) as follows
+
+$$
+x ^ { 0 } = x \mathrm { ~ , ~ } \quad \quad x ^ { t } = c l i p _ { x , \lambda } \left( x ^ { t - 1 } + k \mathrm { s i g n } ( \mathcal { I } ( \theta , x ^ { t - 1 } , y ) ) \right) ,
+$$
+
+where function $c l i p _ { x , \lambda }$ is a projection into a $L _ { \infty }$ -ball of radius $\lambda$ centered at $x$ , and also into the hyper-cube of image space (each pixel is clipped to the range of $[ 0 , 2 5 5 ] ,$ ). The dense and SAP-100 models are tested against this adversarial attack, with $k = 1 . 0$ (Fig. 1c). The accuracies of the dense model at $\lambda = 0$ , 1, 2 and 4 are $8 9 . 8 \%$ , $6 6 . 3 \%$ , $5 0 . 1 \%$ and $3 1 . 0 \%$ respectively. The accuracies of the SAP-100 model against attacks computed on the same model (with $1 0 \mathrm { M C }$ samples taken at each step to estimate the gradient) are $8 3 . 3 \%$ , $8 2 . 0 \%$ , $8 0 . 2 \%$ and $7 6 . 7 \%$ , for $\lambda = 0 , 1 , 2 , 4$ respectively. The SAP-100 model provides accuracies of $8 3 . 3 \%$ , $7 5 . 2 \%$ , $6 7 . 0 \%$ and $5 0 . 8 \%$ , against attacks computed on the dense model, with the perturbations $\lambda = 0 , 1 , 2 , 4$ respectively. Iterative attacks on the SAP models are much more expensive to compute and noisier than iterative attacks on dense models. This is why the adversarial attack computed on the dense model results in lower accuracies on the SAP-100 model than the adversarial attack computed on the SAP-100 model itself.
+
+# 5 RELATED WORK
+
+Robustness to adversarial attack has recently emerged as a serious topic in machine learning (Goodfellow et al., 2014; Kurakin et al., 2016; Papernot & McDaniel, 2016; Tramèr et al., 2017b; Fawzi et al., 2018). Goodfellow et al. (2014) introduced FGSM. Kurakin et al. (2016) proposed an iterative method where FGSM is used for smaller step sizes, which leads to a better approximation of the gradient. Papernot et al. (2017) observed that adversarial examples could be transferred to other models as well. Madry et al. (2017) introduce adding random noise to the image and then using the FGSM method to come up with adversarial examples.
+
+Being robust against adversarial examples has primarily focused on training on the adversarial examples. Goodfellow et al. (2014) use FGSM to inject adversarial examples into their training dataset. Madry et al. (2017) use an iterative FGSM approach to create adversarial examples to train on. Tramèr et al. (2017a) introduced an ensemble adversarial training method of training on the adversarial examples created on the model itself and an ensemble of other pre-trained models. These works have been successful, achieving only a small drop in accuracy form the clean and adversarially generated data. Nayebi & Ganguli (2017) proposes a method to produce a smooth input-output mapping by using saturating activation functions and causing the activations to become saturated.
+
+# 6 CONCLUSION
+
+The SAP approach guards networks against adversarial examples without requiring any additional training. We showed that in the adversarial setting, applying SAP to image classifiers improves both the accuracy and calibration. Notably, combining SAP with adversarial training yields additive benefits. Additional experiments show that SAP can also be effective against adversarial examples in reinforcement learning.
+
+# REFERENCES
+
+Vahid Behzadan and Arslan Munir. Vulnerability of deep reinforcement learning to policy induction attacks. arXiv preprint arXiv:1701.04143, 2017.
+
+Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. J. Artif. Intell. Res.(JAIR), 47:253–279, 2013.
+
+Tianqi Chen, Mu Li, Yutian Li, Min Lin, Naiyan Wang, Minjie Wang, Tianjun Xiao, Bing Xu, Chiyuan Zhang, and Zheng Zhang. Mxnet: A flexible and efficient machine learning library for heterogeneous distributed systems. arXiv preprint arXiv:1512.01274, 2015.
+
+Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Analysis of classifiers’ robustness to adversarial perturbations. Machine Learning, 107(3):481–508, 2018.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q Weinberger. On calibration of modern neural networks. arXiv preprint arXiv:1706.04599, 2017.
+
+Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015.
+
+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.
+
+Sandy Huang, Nicolas Papernot, Ian Goodfellow, Yan Duan, and Pieter Abbeel. Adversarial attacks on neural network policies. arXiv preprint arXiv:1702.02284, 2017.
+
+Jernej Kos and Dawn Song. Delving into adversarial attacks on deep policies. arXiv preprint arXiv:1705.06452, 2017.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016.
+
+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.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
+
+Aran Nayebi and Surya Ganguli. Biologically inspired protection of deep networks from adversarial attacks. arXiv preprint arXiv:1703.09202, 2017.
+
+Martin J Osborne and Ariel Rubinstein. A course in game theory. MIT press, 1994.
+
+Nicolas Papernot and Patrick McDaniel. On the effectiveness of defensive distillation. arXiv preprint arXiv:1607.05113, 2016.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the 2017 ACM on Asia Conference on Computer and Communications Security, pp. 506–519. ACM, 2017.
+
+Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of machine learning research, 15(1):1929–1958, 2014.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Florian Tramèr, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick McDaniel. Ensemble adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017a.
+
+Florian Tramèr, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick McDaniel. The space of transferable adversarial examples. arXiv preprint arXiv:1704.03453, 2017b.
+
+# A REINFORCEMENT LEARNING MODEL ARCHITECTURE
+
+For the experiments in section 4.2, we trained the network with RMSProp, minibatches of size 32, a learning rate of 0.00025, and a momentum of 0.95 and as in (Mnih et al., 2015) where the discount factor is $\gamma = 0 . 9 9$ , the number of steps between target updates to 10000 steps. We updated the network every 4 steps by randomly sampling a minibatch of size 32 samples from the replay buffer and trained the agents for a total of $1 0 0 M$ steps per game. The experience replay contains the $1 M$ most recent transitions. For training we used an $\varepsilon$ -greedy policy with $\varepsilon$ annealed linearly from 1 to 0.1 over the first $1 M$ time steps and fixed at 0.1 thereafter.
+
+The input to the network is $4 \times 8 4 \times 8 4$ tensor with a rescaled, gray-scale version of the last four observations. The first convolution layer has 32 filters of size 8 with a stride of 4. The second convolution layer has 64 filters of size 4 with stride 2. The last convolution layer has 64 filters of size 3 followed by two fully connected layers with size 512 and the final fully connected layer Q-value of each action where ReLU rectifier is deployed for the nonlinearity at each layer.
+
+# B OTHER METHODS
+
+We tried a variety of different methods that could be added to pretrained models and tested their performance against adversarial examples. The following is a continuation of section 4.1, where we use the dense model again on the CIFAR-10 dataset.
+
+# B.1 RANDOM NOISY WEIGHTS (RNW)
+
+One simple way of introducing stochasticity to the activations is by adding random Gaussian noise to each weight, with mean 0 and constant standard deviation, s. So each weight tensor $W ^ { i }$ now changes to $M ( W ^ { i } )$ , where the $j$ ’th entry is given by
+
+$$
+M ( W ^ { i } ) _ { j } = ( W ^ { i } ) _ { j } + \eta , \qquad \eta \sim \mathcal { N } ( 0 , s ^ { 2 } ) .
+$$
+
+These models behave very similar to the dense model (Fig. 5a, the legend indicates the value of $s$ ). While we test several different values of $s$ , we do not observe any significant improvements regarding robustness against adversarial examples. As $s$ increased, the accuracy for non-zero $\lambda$ decreased.
+
+# B.2 RANDOMLY SCALED WEIGHTS (RSW)
+
+Instead of using additive noise, we also try multiplicative noise. The scale factor can be picked from a Gaussian distribution, with mean 1 and constant standard deviation s. So each weight tensor $W ^ { i }$ now changes to $M ( W ^ { i } )$ , where the $j$ ’th entry is given by
+
+$$
+M ( W ^ { i } ) _ { j } = \eta \cdot ( W ^ { i } ) _ { j } , \qquad \eta \sim { \mathcal { N } } ( 1 , s ^ { 2 } ) .
+$$
+
+These models perform similar to the dense model, but again, no robustness is offered against adversarial examples. They follow a similar trend as the RNW models (Figure 5b, the legend indicates the value of $s$ ).
+
+# B.3 DETERMINISTIC WEIGHT PRUNING (DWP)
+
+Following from the motivation of preventing perturbations to propagate forward in the network, we tested deterministic weight pruning, where the top $k \%$ entries of a weight matrix were kept, while the rest were pruned to 0, according to their absolute values. This method was prompted by the success achieved by this pruning method, introduced by Han et al. (2015), where they also fine-tuned the model.
+
+For low levels of pruning, these models do very similar to the dense model, even against adversarial examples (Fig. 5c, the legend indicates the value of $k$ ). The adversary can compute the gradient of the sparse model, and the perturbations propagate forward through the surviving weights. For higher levels of sparsity, the accuracy in the no-perturbation case drops down quickly.
+
+# B.4 STOCHASTIC WEIGHT PRUNING (SWP)
+
+Observing the failure of deterministic weight pruning, we tested a mix of stochasticity and pruning, the stochastic weight pruning method. Very similar to the idea of SAP, we consider all the entries of a weight tensor to be a multinomial distribution, and we sample from it with replacement. For a weight tensor $W ^ { i } \in \mathbb { R } ^ { a ^ { i } }$ , we sample from it $r ^ { i }$ times with replacement. The probability of sampling $( W ^ { \bar { i } } ) _ { j }$ is given by
+
+$$
+p _ { j } ^ { i } = \frac { | ( W ^ { i } ) _ { j } | } { \sum _ { k = 1 } ^ { a ^ { i } } | ( W ^ { i } ) ) _ { k } | } .
+$$
+
+The new weight entry, $M ( W ^ { i } ) _ { j }$ , is given by
+
+$$
+M ( W ^ { i } ) _ { j } = W _ { j } ^ { i } \cdot \frac { \mathbb { I } ( W _ { j } ^ { i } ) } { 1 - ( 1 - p _ { i } ) ^ { r ^ { i } } } ,
+$$
+
+where $\mathbb { I } ( W _ { j } ^ { i } )$ is the indicator function that returns 1 if $W _ { j } ^ { i }$ was sampled at least once, and 0 otherwise.
+
+For these experiments, for each weight matrix $W ^ { i } \in \mathbb { R } ^ { m ^ { i } }$ , the number of samples picked were $k \%$ of $m ^ { i }$ . Since samples were picked with replacement, $k$ could be more than 100. We will refer to $k$ as the percentage of samples drawn.
+
+These models behave very similar to the dense model. We tried drawing range of percentages of samples, but no evident robustness could be seen against adversarial examples (Figure 5d, the legend indicates the value of $k$ ). For a small $s$ , it is very similar to the dense model. As $s$ increases, the these models do marginally better for low non-zero $\lambda$ values, and then drops again (similar to the SAP case).
+
+# B.5 RANDOM NOISY ACTIVATIONS (RNA)
+
+Next we change our attention to the activation maps in the dense model. One simple way of introducing stochasticity to the activations is by adding random Gaussian noise to each activation entry, with mean 0 and constant standard deviation, $s$ . So each activation map $h ^ { i }$ now changes to $M ( h ^ { i } )$ , where the $j ^ { : }$ ’th entry is given by
+
+$$
+M ( h ^ { i } ) _ { j } = ( h ^ { i } ) _ { j } + \eta , \qquad \eta \sim \mathcal { N } ( 0 , s ^ { 2 } ) .
+$$
+
+These models too do not offer any robustness against adversarial examples. Their accuracy drops quickly with $\lambda$ and $s$ (Fig. 5e, the legend indicates the value of $s$ ).
+
+# B.6 RANDOMLY SCALED ACTIVATIONS (RSA)
+
+Instead of having additive noise, we can also make the model stochastic by scaling the activations. The scale factor can be picked from a Gaussian distribution, with mean 1 and constant standard deviation $s$ . So each activation map $h ^ { i }$ now changes to $M ( h ^ { i } )$ , where the $j$ ’th entry is given by
+
+$$
+M ( h ^ { i } ) _ { j } = \eta ( h ^ { i } ) _ { j } , \qquad \eta \sim { \mathcal { N } } ( 1 , s ^ { 2 } ) .
+$$
+
+These models perform similar to the dense model, exhibiting no additional robustness against adversarial examples (Figure 5f, the legend indicates the value of $s$ ).

parse/train/H1uR4GZRZ/H1uR4GZRZ_content_list.json

@@ -0,0 +1,1643 @@
+[
+    {
+        "type": "text",
+        "text": "STOCHASTIC ACTIVATION PRUNING FOR ROBUST ADVERSARIAL DEFENSE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            101,
+            655,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Guneet S. Dhillon1,2, Kamyar Azizzadenesheli3, Zachary C. Lipton $^ { 1 , 4 }$ ,   \nJeremy Bernstein1,5, Jean Kossaifi1,6, Aran Khanna1, Anima Anandkumar1,5   \n1Amazon AI, 2UT Austin, 3UC Irvine, 4CMU, 5Caltech, 6Imperial College London   \nguneetdhillon@utexas.edu, kazizzad@uci.edu, zlipton@cmu.edu, bernstein@caltech.edu, jean.kossaifi@imperial.ac.uk, aran@arankhanna.com, anima@amazon.com ",
+        "bbox": [
+            186,
+            167,
+            779,
+            255
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            291,
+            544,
+            306
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural networks are known to be vulnerable to adversarial examples. Carefully chosen perturbations to real images, while imperceptible to humans, induce misclassification and threaten the reliability of deep learning systems in the wild. To guard against adversarial examples, we take inspiration from game theory and cast the problem as a minimax zero-sum game between the adversary and the model. In general, for such games, the optimal strategy for both players requires a stochastic policy, also known as a mixed strategy. In this light, we propose Stochastic Activation Pruning (SAP), a mixed strategy for adversarial defense. SAP prunes a random subset of activations (preferentially pruning those with smaller magnitude) and scales up the survivors to compensate. We can apply SAP to pretrained networks, including adversarially trained models, without fine-tuning, providing robustness against adversarial examples. Experiments demonstrate that SAP confers robustness against attacks, increasing accuracy and preserving calibration. ",
+        "bbox": [
+            233,
+            324,
+            766,
+            505
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            535,
+            336,
+            551
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While deep neural networks have emerged as dominant tools for supervised learning problems, they remain vulnerable to adversarial examples (Szegedy et al., 2013). Small, carefully chosen perturbations to input data can induce misclassification with high probability. In the image domain, even perturbations so small as to be imperceptible to humans can fool powerful convolutional neural networks (Szegedy et al., 2013; Goodfellow et al., 2014). This fragility presents an obstacle to using machine learning in the wild. For example, a vision system vulnerable to adversarial examples might be fundamentally unsuitable for a computer security application. Even if a vision system is not explicitly used for security, these weaknesses might be critical. Moreover, these problems seem unnecessary. If these perturbations are not perceptible to people, why should they fool a machine? ",
+        "bbox": [
+            174,
+            568,
+            825,
+            694
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Since this problem was first identified, a rapid succession of papers have proposed various techniques both for generating and for guarding against adversarial attacks. Goodfellow et al. (2014) introduced a simple method for quickly producing adversarial examples called the fast gradient sign method (FGSM). To produce an adversarial example using FGSM, we update the inputs by taking one step in the direction of the sign of the gradient of the loss with respect to the input. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            770
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To defend against adversarial examples some papers propose training the neural network on adversarial examples themselves, either using the same model (Goodfellow et al., 2014; Madry et al., 2017), or using an ensemble of models (Tramèr et al., 2017a). Taking a different approach, Nayebi & Ganguli (2017) draws inspiration from biological systems. They propose that to harden neural networks against adversarial examples, one should learn flat, compressed representations that are sensitive to a minimal number of input dimensions. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces Stochastic Activation Pruning (SAP), a method for guarding pretrained networks against adversarial examples. During the forward pass, we stochastically prune a subset of the activations in each layer, preferentially retaining activations with larger magnitudes. Following the pruning, we scale up the surviving activations to normalize the dynamic range of the inputs to the subsequent layer. Unlike other adversarial defense methods, our method can be applied post-hoc to pretrained networks and requires no additional fine-tuning. ",
+        "bbox": [
+            174,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            152,
+            339,
+            169
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We denote an $n$ -layered neural network $h : \\mathcal { X }  Y$ as a chain of functions $h = h ^ { n } \\circ h ^ { n - 1 } \\circ . . . \\circ h ^ { 1 }$ , where each $h ^ { i }$ consists of a linear transformation $W ^ { i }$ followed by a non-linearity $\\phi ^ { i }$ . Given a set of nonlinearities and weight matrices, a neural network provides a nonlinear mapping from inputs $x \\in \\mathcal { X }$ to outputs $\\hat { y } \\in \\mathcal { V }$ , i.e. ",
+        "bbox": [
+            173,
+            183,
+            826,
+            239
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/18ad2d52d9faf0487523672cf88a8a42fd848e9e1e6e8c2392c28b77e5cc46b8.jpg",
+        "text": "$$\n\\hat { y } : = h ( x ) = \\phi ^ { n } ( W ^ { n } \\phi ^ { n - 1 } ( W ^ { n - 1 } \\phi ^ { n - 2 } ( . . . \\phi ^ { 1 } ( W ^ { 1 } x ) ) ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            244,
+            687,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In supervised classification and regression problems, we are given a data set $\\mathcal { D }$ of pairs $( x , y )$ , where each pair is drawn from an unknown joint distribution. For the classification problems, $y$ is a categorical random variable, and for regression, $y$ is a real-valued vector. Conditioned on a given dataset, network architecture, and a loss function such as cross entropy, a learning algorithm, e.g. stochastic gradient descent, learns parameters $\\theta : = \\{ W ^ { i } \\} _ { i = 1 } ^ { n }$ in order to minimize the loss. We denote $J ( \\theta , x , y )$ as the loss of a learned network, parameterized by $\\theta$ , on a pair of $( x , y )$ . To simplify notation, we focus on classification problems, although our methods are broadly applicable. ",
+        "bbox": [
+            173,
+            276,
+            826,
+            375
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Consider an input $x$ that is correctly classified by the model $h$ . An adversary seeks to apply a small additive perturbation, $\\Delta x$ , such that $h ( x ) \\neq h ( x + \\Delta x )$ , subject to the constraint that the perturbation is imperceptible to a human. For perturbations applied to images, the $l _ { \\infty }$ -norm is considered a better measure of human perceptibility than the more familiar $l _ { 2 }$ norm Goodfellow et al. (2014). Throughout this paper, we assume that the manipulative power of the adversary, the perturbation $\\Delta x$ , is of bounded norm $\\| \\Delta x \\| _ { \\infty } \\leq \\lambda$ . Given a classifier, one common way to generate an adversarial example is to perturb the input in the direction that increases the cross-entropy loss. This is equivalent to minimizing the probability assigned to the true label. Given the neural network $h$ , network parameters $\\theta$ , input data $x$ , and corresponding true output $y$ , an adversary could create a perturbation $\\Delta x$ as follows ",
+        "bbox": [
+            173,
+            381,
+            825,
+            520
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8bf26a3d55d640d7d9944703704348eb3f99e9ad2b6dc7ef52d227095a0bf068.jpg",
+        "text": "$$\n\\Delta x = \\arg \\operatorname* { m a x } _ { \\| r \\| \\infty } J ( \\theta , x + r , y ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            526,
+            609,
+            553
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Due to nonlinearities in the underlying neural network, and therefore of the objective function $J$ , the optimization Eq. 1, in general, can be a non-convex problem. Following Madry et al. (2017); Goodfellow et al. (2014), we use the first order approximation of the loss function ",
+        "bbox": [
+            173,
+            558,
+            826,
+            602
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6d348687a273bfe9f98bffcb75d9075bbde5e5e28ea55217bbd62ab2f2318553.jpg",
+        "text": "$$\n\\Delta x = \\arg \\operatorname* { m a x } _ { \\| r \\| _ { \\infty } \\leq \\lambda } [ J ( \\theta , x , y ) + r ^ { \\top } \\mathcal { T } ( \\theta , x , y ) ] , \\qquad \\mathrm { w h e r e ~ } \\mathcal { I } = \\nabla _ { x } J .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            606,
+            746,
+            635
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The first term in the optimization is not a function of the adversary perturbation, therefore reduces to ",
+        "bbox": [
+            178,
+            640,
+            825,
+            655
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a991d089a2bbe48a0f3410caf0317cff8bb3f834dd6b8ecaec30ff9b6d216dd9.jpg",
+        "text": "$$\n\\Delta x = \\arg \\operatorname* { m a x } _ { \\| r \\| _ { \\infty } \\leq \\lambda } { r ^ { \\top } \\mathcal { I } ( \\theta , x , y ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            661,
+            606,
+            688
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "An adversary chooses $r$ to be in the direction of sign of $\\mathcal { I } ( \\theta , x , y )$ , i.e. $\\Delta x = \\lambda \\cdot \\mathrm { s i g n } ( \\mathcal { I } ( \\theta , x , y ) )$ . This is the FGSM technique due to Goodfellow et al. (2014). Note that FGSM requires an adversary to access the model in order to compute the gradient. ",
+        "bbox": [
+            173,
+            695,
+            826,
+            738
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 STOCHASTIC ACTIVATION PRUNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            758,
+            501,
+            773
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Consider the defense problem from a game-theoretic perspective (Osborne & Rubinstein, 1994). The adversary designs a policy in order to maximize the defender’s loss, while knowing the defenders policy. At the same time defender aims to come up with a strategy to minimize the maximized loss. Therefore, we can rewrite Eq. 1 as follows ",
+        "bbox": [
+            173,
+            789,
+            826,
+            845
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b5b249a0b6b409c60e79a1a279d6f6bc1e24a0c80a20f6ad3101c8248ea11851.jpg",
+        "text": "$$\n\\pi ^ { * } , \\rho ^ { * } : = \\arg \\operatorname* { m i n } _ { \\pi } \\operatorname* { m a x } _ { \\rho } \\mathbb { E } _ { p \\sim \\pi , r \\sim \\rho } \\left[ J ( M _ { p } ( \\theta ) , x + r , y ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            852,
+            686,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\rho$ is the adversary’s policy, which provides $r \\sim \\rho$ in the space of bounded (allowed) perturbations (for any $r$ in range of $\\rho$ , $\\| r \\| _ { \\infty } \\leq \\bar { \\lambda } )$ and $\\pi$ is the defenders policy which provides $p \\sim \\pi$ , an instantiation of its policy. The adversary’s goal is to maximize the loss of the defender by perturbing ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Stochastic Activation Pruning (SAP) ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            103,
+            503,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/ab1aa898ad8cde8dba213eb54c27b47370c32f8d66065a66db8c4a0b53cc51c5.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>1:</td><td colspan=\"3\">Input: input datum x, neural network with n layers, with ith layer having weight matrix Wi, non-linearity $i and number of samples to be drawn r𝑖 .</td></tr><tr><td>2:</td><td>h←x</td><td></td><td></td></tr><tr><td>3:</td><td>for each layeri do</td><td></td><td></td></tr><tr><td>h² ←²(Wihi-1)</td><td></td><td></td><td>&gt;activation vector for layer i with dimension ai</td></tr><tr><td>4: 5:</td><td>p← (h²)j</td><td>∀j ∈{1,...,a²}</td><td>&gt;activations normalized on to the simplex</td></tr><tr><td>6:</td><td>s←0</td><td>∑=1(h）1</td><td>&gt; set of indices not to be pruned</td></tr><tr><td>7:</td><td>repeat ri times</td><td></td><td>&gt; the activations have ri chances of being kept</td></tr><tr><td>8:</td><td></td><td>Draw s ~ categorical(p)</td><td>draw an index to be kept</td></tr><tr><td>9:</td><td>S←SU{s}</td><td></td><td>add index s to the keep set</td></tr><tr><td>10:</td><td>for each j  Sdo</td><td></td><td></td></tr><tr><td>11:</td><td>(h²)←0</td><td></td><td> prune the activations not in S</td></tr><tr><td>12:</td><td>for each j ∈ S do</td><td></td><td></td></tr><tr><td>13:</td><td>(h²);← (h²)j</td><td></td><td>&gt; scale up the activations in S</td></tr><tr><td></td><td>1-(1-p）m</td><td></td><td></td></tr><tr><td></td><td>14: return hn</td><td></td><td></td></tr></table>",
+        "bbox": [
+            176,
+            123,
+            826,
+            364
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "the input under a strategy $\\rho$ and the defender’s goal is to minimize the loss by changing model parameters $\\theta$ to $M _ { p } ( \\theta )$ under strategy $\\pi$ . The optimization problem in Eq. 2 is a minimax zero-sum game between the adversary and defender where the optimal strategies $( \\pi ^ { * } , \\rho ^ { * } )$ , in general, are mixed Nash equilibrium, i.e. stochastic policies. ",
+        "bbox": [
+            173,
+            393,
+            825,
+            450
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, the idea of SAP is to stochastically drop out nodes in each layer during forward propagation. We retain nodes with probabilities proportional to the magnitude of their activation and scale up the surviving nodes to preserve the dynamic range of the activations in each layer. Empirically, the approach preserves the accuracy of the original model. Notably, the method can be applied post-hoc to already-trained models. ",
+        "bbox": [
+            173,
+            457,
+            825,
+            526
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Formally, assume a given pretrained model, with activation layers (ReLU, Sigmoid, etc.) and input pair of $( x , y )$ . For each of those layers, SAP converts the activation map to a multinomial distribution, choosing each activation with a probability proportional to its absolute value. In other words, we obtain the multinomial distribution of each activation layer with $L _ { 1 }$ normalization of their absolute values onto a $L _ { 1 }$ -ball simplex. Given the $i$ ’th layer activation map, $h ^ { i } \\in \\mathbb { R } ^ { a ^ { i } }$ , the probability of sampling the $j ^ { ; }$ ’th activation with value $( h ^ { i } ) _ { j }$ is given by ",
+        "bbox": [
+            173,
+            532,
+            826,
+            621
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/727a63e82aac29d6f1fadb186fb6bf4ccf98c81d00d175e69708744547090343.jpg",
+        "text": "$$\np _ { j } ^ { i } = \\frac { | ( h ^ { i } ) _ { j } | } { \\sum _ { k = 1 } ^ { a ^ { i } } | ( h ^ { i } ) _ { k } | } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            628,
+            568,
+            669
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We draw random samples with replacement from the activation map given the probability distribution described above. This makes it convenient to determine whether an activation would be sampled at all. If an activation is sampled, we scale it up by the inverse of the probability of sampling it over all the draws. If not, we set the activation to 0. In this way, SAP preserves inverse propensity scoring of each activation. Under an instance $p$ of policy $\\pi$ , we draw $r _ { p } ^ { i }$ samples with replacement from this multinomial distribution. The new activation map, $M _ { p } ( h ^ { i } )$ is given by ",
+        "bbox": [
+            174,
+            675,
+            825,
+            763
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3ee2e4e7270a95d5c88eb3b657dfe5e078f3caceeb8aae3fdb17c9f089bb1985.jpg",
+        "text": "$$\nM _ { p } ( h ^ { i } ) = h ^ { i } \\odot m _ { p } ^ { i } , \\qquad ( m _ { p } ^ { i } ) _ { j } = \\frac { \\mathbb { I } ( ( h ^ { i } ) _ { j } ) } { 1 - ( 1 - p _ { j } ^ { i } ) ^ { r _ { p } ^ { i } } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            771,
+            709,
+            810
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { I } ( ( h ^ { i } ) _ { j } )$ is the indicator function that returns 1 if $( h ^ { i } ) _ { j }$ was sampled at least once, and 0 otherwise. The algorithm is described in Algorithm 1. In this way, the model parameters are changed from $\\theta$ to $M _ { p } ( \\theta )$ , for instance $p$ under policy $\\pi$ , while the reweighting $1 - ( 1 - p _ { j } ^ { i } ) ^ { r _ { p } ^ { i } }$ preserves $\\mathbb { E } _ { p \\sim \\pi } [ M _ { p } ( h ^ { i } ) _ { j } ] = ( h ^ { i } ) _ { j }$ . If the model was linear, the proposed pruning method would behave the same way as the original model in expectation. In practice, we find that even with the non-linearities in deep neural networks, for sufficiently many examples, SAP performs similarly to the un-pruned model. This guides our decision to apply SAP to pretrained models without performing fine-tuning. ",
+        "bbox": [
+            173,
+            819,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 ADVANTAGE AGAINST ADVERSARIAL ATTACK ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            104,
+            529,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We attempt to explain the advantages of SAP under the assumption that we are applying it to a pre-trained model that achieves high generalization accuracy. For instance $p$ under policy $\\pi$ , if the number of samples drawn for each layer $i$ , $r _ { p } ^ { i }$ , is large, then fewer parameters of the neural network are pruned, and the scaling factor gets closer to 1. Under this scenario, the stochastically pruned model performs almost identically to the original model. The stochasticity is not advantageous in this case, but there is no loss in accuracy in the pruned model as compared to the original model. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            213
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, with fewer samples in each layer, $r _ { p } ^ { i }$ , a large number of parameters of the neural network are pruned. Under this scenario, the SAP model’s accuracy will drop compared to the original model’s accuracy. But this model is stochastic and has more freedom to deceive the adversary. So the advantage of SAP comes if we can balance the number of samples drawn in a way that negligibly impacts accuracy but still confers robustness against adversarial attacks. ",
+        "bbox": [
+            174,
+            219,
+            825,
+            290
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "SAP is similar to the dropout technique due to Srivastava et al. (2014). However, there is a crucial difference: SAP is more likely to sample activations that are high in absolute value, whereas dropout samples each activation with the same probability. Because of this difference, SAP, unlike dropout, can be applied post-hoc to pretrained models without significantly decreasing the accuracy of the model. Experiments comparing SAP and dropout are included in section 4. Interestingly, dropout confers little advantage over the baseline. We suspect that the reason for this is that the dropout training procedure encourages all possible dropout masks to result in similar mappings. ",
+        "bbox": [
+            174,
+            296,
+            825,
+            395
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 ADVERSARIAL ATTACK ON SAP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            411,
+            433,
+            426
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If the adversary knows that our defense policy is to apply SAP, it might try to calculate the best strategy against the SAP model. Given the neural network $h$ , input data $x$ , corresponding true output $y$ , a policy $\\rho$ over the allowed perturbations, and a policy $\\pi$ over the model parameters that come from SAP (this result holds true for any stochastic policy chosen over the model parameters), the adversary determines the optimal policy $\\rho ^ { * }$ ",
+        "bbox": [
+            174,
+            438,
+            825,
+            508
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/084c23ebff9d378cecdd14243cdc90a9a06dc40077816be9f973932c111cf8db.jpg",
+        "text": "$$\n\\rho ^ { * } = \\arg \\operatorname* { m a x } _ { \\rho } \\mathbb { E } _ { p \\sim \\pi , r \\sim \\rho } [ J ( M _ { p } ( \\theta ) , x + r , y ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            513,
+            650,
+            537
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Therefore, using the result from section 2, the adversary determines the perturbation $\\Delta x$ as follows; ",
+        "bbox": [
+            173,
+            545,
+            823,
+            560
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fcb4515775c4da89cb6efe0057bbf310f9e4ec6516c0c62a67a083605486e089.jpg",
+        "text": "$$\n\\Delta x = \\arg \\operatorname* { m a x } _ { r } r ^ { \\top } \\mathbb { E } _ { p \\sim \\pi } [ \\mathcal { I } ( M _ { p } ( \\theta ) , x , y ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            565,
+            637,
+            590
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To maximize the term, the adversary will set $r$ to be in the direction of sign of $\\mathbb { E } _ { p \\sim \\pi } [ \\mathcal { I } ( M _ { p } ( \\theta ) , x , y ) ]$ . Analytically computing $\\mathbb { E } _ { p \\sim \\pi } [ \\mathcal { T } ( M _ { p } ( \\theta ) , x , y ) ]$ is not feasible. However, the adversary can use Monte Carlo (MC) sampling to estimate the expectation as $\\mathcal { \\widetilde { I } } ( M _ { p } ( \\theta ) , x , y )$ . Then, using FGSM, $\\Delta x = \\lambda \\cdot \\mathrm { s i g n } ( \\widetilde { \\mathcal { I } } ( M _ { p } ( \\theta ) , x , y ) )$ . ",
+        "bbox": [
+            173,
+            597,
+            826,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            681,
+            326,
+            696
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our experiments to evaluate SAP address two tasks: image classification and reinforcement learning. We apply the method to the $R e L U$ activation maps at each layer of the pretrained neural networks. To create adversarial examples in our evaluation, we use FGSM, $\\Delta x = \\lambda \\cdot \\mathrm { s i g n } ( \\mathcal { I } ( M _ { p } ( \\theta ) , x , y ) )$ . For stochastic models, the adversary estimates $\\mathcal { I } ( M _ { p } ( \\theta ) , x , y )$ using MC sampling unless otherwise mentioned. All perturbations are applied to the pixel values of images, which normally take values in the range 0-255. So the fraction of perturbation with respect to the data’s dynamic range would be λ256 . To ensure that all images are valid, even following perturbation, we clip the resulting pixel values so that they remain within the range $[ 0 , 2 5 5 ]$ . In all plots, we consider perturbations of the following magnitudes $\\lambda = \\{ 0 , 1 , 2 , 4 , 8 , 1 6 , 3 \\dot { 2 } , 6 4 \\}$ .1 ",
+        "bbox": [
+            173,
+            712,
+            826,
+            838
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To evaluate models in the image classification domain, we look at two aspects: the model accuracy for varying values of $\\lambda$ , and the calibration of the models (Guo et al., 2017). Calibration of a model is the relation between the confidence level of the model’s output and its accuracy. A linear calibration is ideal, as it suggests that the accuracy of the model is proportional to the confidence level of its output. To evaluate models in the reinforcement learning domain, we look at the average score that each model achieves on the games played, for varying values of $\\lambda$ . The higher the score, the better is the model’s performance. Because the units of reward are arbitrary, we report results in terms of the the relative percent change in rewards. In both cases, the output of stochastic models are computed as an average over multiple forward passes. ",
+        "bbox": [
+            174,
+            844,
+            825,
+            887
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/2cfc5effd361d7be95015576fa66a9f8a0ef5ab0cf3e5cfe5cdb2b6e5fea6796.jpg",
+        "image_caption": [
+            "Figure 1: Accuracy plots of a variety of attacks against dense model and SAP models with different perturbation strengths, $\\lambda$ . For the SAP $\\tau \\%$ models, $\\tau$ denotes the percentages of samples drawn from the multinomial distribution, at each layer. $( a )$ SAP models tested against random perturbation. $( b )$ SAP models tested against the FGSM attack, using MC sampling. $( c )$ SAP-100 tested against an iterative adversarial attack, using MC sampling (legend shows defender vs. adversary). It is worth restating that obtaining the iterative attack of SAP models is much more expensive and noisier than the iterative attack of dense models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            108,
+            807,
+            237
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            375,
+            825,
+            459
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 ADVERSARIAL ATTACKS IN IMAGE CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            478,
+            573,
+            491
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The CIFAR-10 dataset (Krizhevsky & Hinton, 2009) was used for the image classification domain. We trained a ResNet-20 model (He et al., 2016) using SGD, with minibatches of size 512, momentum of 0.9, weight decay of 0.0001, and a learning rate of 0.5 for the first 100 epochs, then 0.05 for the next 30 epochs, and then 0.005 for the next 20 epochs. This achieved an accuracy of $8 9 . 8 \\%$ with cross-entropy loss and $R e L U$ non-linearity. For all the figures in this section, we refer to this model as the dense model. The accuracy of the dense model degrades quickly with $\\lambda$ . For $\\lambda = 1$ , the accuracy drops down to $6 6 . 3 \\%$ , and for $\\lambda = 2$ it is $5 6 . 4 \\%$ . These are small (hardly perceptible) perturbations in the input images, but the dense model’s accuracy decreases significantly. ",
+        "bbox": [
+            173,
+            503,
+            825,
+            616
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 STOCHASTIC ACTIVATION PRUNING (SAP) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            632,
+            521,
+            646
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We apply SAP to the dense model. For each activation map $h ^ { i } \\in \\mathbb { R } ^ { a ^ { i } }$ , we pick $k \\%$ of $a ^ { i }$ activations to keep. Since activations are sampled with replacement, $k$ can be more than 100. We will refer to $k$ as the percentage of samples drawn. Fig. 1a plots performance of SAP models against examples perturbed with random noise. Perturbations of size $\\lambda = 6 4$ are readily perceptible and push all models under consideration to near-random outputs, so we focus our attention on smaller values of $\\lambda$ Fig. 1b plots performance of these models against adversarial examples. With many samples drawn, SAP converges to the dense model. With few samples drawn, accuracy diminishes for $\\lambda = 0$ , but is higher for $\\lambda \\neq 0$ . The plot explains this balance well. We achieve the best performance with $\\sim 1 0 0 \\%$ samples picked. We will now only look at SAP $1 0 0 \\%$ (SAP-100). Against adversarial examples, with $\\lambda = 1$ , 2 and 4, we observe a $1 2 . 2 \\%$ , $1 6 . 3 \\%$ and $1 2 . 8 \\%$ absolute increase in accuracy respectively. However, for $\\lambda = 0$ , we observe a $6 . 5 \\%$ absolute decrease in accuracy. For $\\lambda = 1 6$ again, there is a $5 . 2 \\%$ absolute decrease in accuracy. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            825
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1.2 DROPOUT (DRO) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            843,
+            349,
+            857
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Dropout, a technique due to Srivastava et al. (2014), was also tested to compare with SAP. Similar to the SAP setting, this method was added to the $R e L U$ activation maps of the dense model. We see that low dropout rate perform similar to the dense model for small $\\lambda$ values, but its accuracy starts decreasing very quickly for higher $\\lambda$ values (Fig. 2a). We also trained ResNet-20 models, similar to the dense model, but with different dropout rates. This time, the models were trained for 250 epochs, with an initial learning rate of 0.5, reduced by a factor of 0.1 after 100, 150, 190 and 220 epochs. These models were tested against adversarial examples with and without dropout during validation (Figs. 2b and 2c respectively). The models do similar to the dense model, but do not provide additional robustness. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/cf5a09a72eea72ce85ab14309a4b105445dc4521fa24409190d89249a7f01dfb.jpg",
+        "image_caption": [
+            "Figure 2: Robustness of dropout models, with different rates of dropout (denoted in the legends), against adversarial attacks, using MC sampling, with a variety of perturbation strengths, $\\lambda$ : $( a )$ dropout is applied on the pre-trained models during the validations; $( b )$ the models are trained using dropout, and dropout is applied during the validations; $( c )$ the models are trained using dropout, but dropout is not applied during the validations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            109,
+            807,
+            231
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            342,
+            825,
+            412
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1.3 ADVERSARIAL TRAINING (ADV) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            431,
+            459,
+            445
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Adversarial training (Goodfellow et al., 2014) has emerged a standard method for defending against adversarial examples. It has been adopted by Madry et al. (2017); Tramèr et al. (2017a) to maintain high accuracy levels even for large $\\lambda$ values. We trained a ResNet-20 model, similar to the dense model, with an initial learning rate of 0.5, which was halved every 10 epochs, for a total of 100 epochs. It was trained on a dataset consisting of $8 0 \\%$ un-perturbed data and $2 0 \\%$ adversarially perturbed data, generated on the model from the previous epoch, with $\\lambda = 2$ . This achieved an accuracy of $7 5 . 0 \\%$ on the un-perturbed validation set. Note that the model capacity was not changed. When tested against adversarial examples, the accuracy dropped to $7 2 . 9 \\%$ , $7 0 . 9 \\%$ and $6 7 . 5 \\%$ for $\\lambda = 1 , 2$ and 4 respectively. We ran SAP-100 on the ADV model (referred to as $\\mathrm { \\ A D V { + } S A P { - } 1 0 0 }$ ). The accuracy in the no perturbation case was $7 4 . 1 \\%$ . For adversarial examples, both models act similar to each other for small values of $\\lambda$ . But for $\\lambda = 1 6$ and 32, ADV $^ +$ SAP-100 gets a higher accuracy than ADV by an absolute increase of $7 . 8 \\%$ and $7 . 9 \\%$ respectively. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            625
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare the accuracy- $\\lambda$ plot for dense, SAP-100, ADV and $\\mathrm { \\ A D V + S A P - 1 0 0 }$ models. This is illustrated in Fig. 3 For smaller values of $\\lambda$ , SAP-100 achieves high accuracy. As $\\lambda$ gets larger, ADV+SAP-100 performs better than all the other models. We also compare the calibration plots for these models, in Fig. 4. The dense model is not linear for any $\\lambda \\neq 0$ . The other models are well calibrated (close to linear), and behave similar to each other for $\\lambda \\leq 4$ . For higher values of $\\lambda$ , we see that ADV $^ +$ SAP-100 is the closest to a linearly calibrated model. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            714
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 ADVERSARIAL ATTACKS IN DEEP REINFORCEMENT LEARNING (RL) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            737,
+            683,
+            750
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Previously, (Behzadan & Munir, 2017; Huang et al., 2017; Kos & Song, 2017) have shown that the reinforcement learning agents can also be easily manipulated by adversarial examples. The RL agent learns the long term value $Q ( a , s )$ of each state-action pair $( s , a )$ through interaction with an environment, where given a state $s$ , the optimal action is ar $\\operatorname { g m a x } _ { a } Q ( a , s )$ . A regression based algorithm, Deep Q-Network (DQN)(Mnih et al., 2015) and an improved variant, Double DQN (DDQN) have been proposed for the popular Atari games (Bellemare et al., 2013) as benchmarks. We deploy DDQN algorithm and train an RL agent in variety of different Atari game settings. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Similar to the image classification experiments, we tested SAP on a pretrained model (the model is described in the Appendix section A), by applying the method on the $R e L U$ activation maps. SAP-100 was used for these experiments. Table 1 specifies the relative percentage increase in rewards of SAP-100 as compared to the original model. For all the games, we observe a drop in performance for the no perturbation case. But for $\\lambda \\neq 0$ , the relative increase in rewards is positive (except for $\\lambda = 1$ in the BattleZone game), and is very high in some cases $3 4 2 5 . 9 \\%$ for $\\lambda = 1$ for the Bowling game). ",
+        "bbox": [
+            176,
+            868,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/41f08661db51f681f834b8eeee51c4349cab7a1712609127c17efa7361b51ea1.jpg",
+        "image_caption": [
+            "Figure 3: Accuracy plots of the dense, SAP-100, ADV and ADV $^ +$ SAP-100 models, against adversarial attacks, using MC sampling, with a variety of perturbation strengths, $\\lambda$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            352,
+            116,
+            633,
+            279
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/cd82a04170fe1db66bd326f0afd399ef0c7a8af036637d6956b7fd17149af915.jpg",
+        "image_caption": [
+            "Figure 4: Calibration plots of the dense, SAP-100, ADV and $\\mathrm { A D V + S A P - 1 0 0 }$ models, against adversarial attacks, using MC sampling, with a variety of different perturbation strengths, $\\lambda$ . These plots show the relation between the confidence level of the model’s output and its accuracy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            354,
+            815,
+            713
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            795,
+            823,
+            824
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 ADDITIONAL BASELINES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            842,
+            387,
+            856
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In addition to experimenting with SAP, dropout, and adversarial training, we conducted extensive experiments with other methods for introducing stochasticity into a neural network. These techniques included 0-mean Gaussian noise added to weights (RNW), 1-mean multiplicative Gaussian noise for the weights (RSW), and corresponding additive (RNA) and multiplicative (RSA) noise added to ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Relative percentage increase in rewards gained for SAP-100 compared to original model while playing different Atari games. ",
+        "bbox": [
+            173,
+            101,
+            823,
+            128
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/0782270c7b2562c254913c5a8ba9efc409cae14f5750141d9ec12138f51f2640.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>入</td><td>Assault</td><td>Asterix</td><td>BankHeist</td><td>BattleZone</td><td>BeamRider</td><td>Bowling</td></tr><tr><td>0</td><td>-12.2%</td><td>-33.4%</td><td>-59.2%</td><td>-65.8%</td><td>-15.8%</td><td>-4.5%</td></tr><tr><td>1</td><td>10.4%</td><td>13.3%</td><td>131.7%</td><td>-22.0%</td><td>164.5%</td><td>3425.9%</td></tr><tr><td>2</td><td>9.8%</td><td>20.8%</td><td>204.8%</td><td>110.1%</td><td>92.3%</td><td></td></tr><tr><td>4</td><td>12.4%</td><td>14.0%</td><td>1760.0%</td><td>202.6%</td><td></td><td></td></tr><tr><td>8</td><td>16.6%</td><td>7.4%</td><td>60.9%</td><td>134.8%</td><td></td><td></td></tr></table>",
+        "bbox": [
+            312,
+            147,
+            691,
+            218
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/11be80ac9647eec18d0188fde068ff458ea586f8c9047924aed06548372995fa.jpg",
+        "image_caption": [
+            "Figure 5: Robustness of different pruning and noisifying strategies against their respective adversarial attacks (MC sampling used to estimate gradients of stochastic models). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            248,
+            821,
+            515
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "the activations. We describe each method in detail in Appendix B. Each of these models performs worse than the dense baseline at most levels of perturbation and none matches the performance of SAP. Precisely why SAP works while other methods introducing stochasticity do not, remains an open question that we continue to explore in future work. ",
+        "bbox": [
+            174,
+            584,
+            825,
+            640
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 SAP ATTACKS WITH VARYING NUMBERS OF MC SAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            660,
+            612,
+            674
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In the previous experiments the SAP adversary used $1 0 0 ~ \\mathrm { M C }$ samples to estimate the gradient. Additionally, we compared the performance of SAP-100 against various attacks, these include the standard attack calculated based on the dense model and those generated on SAP-100 by estimating the gradient with various numbers of MC samples. We see that if the adversary uses the dense model to generate adversarial examples, SAP-100 model’s accuracy decreases. Additionally, if the adversary uses the SAP-100 model to generate adversarial examples, greater numbers of MC samples lower the accuracy more. Still, even with $1 0 0 0 \\mathbf { M C }$ samples, for low amounts of perturbation ( $\\lambda = 1$ and 2), SAP-100 retains higher accuracy than the dense model. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            799
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Computing a single backward pass of the SAP-100 model for 512 examples takes $\\sim 2 0$ seconds on 8 GPUs. Using 100 and $1 0 0 0 \\mathbf { M C }$ samples would take $\\sim 0 . 6$ and $\\sim 6$ hours respectively. ",
+        "bbox": [
+            174,
+            806,
+            823,
+            834
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.5 ITERATIVE ADVERSARIAL ATTACK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            854,
+            450,
+            868
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A more sophisticated technique for producing adversarial perturbations (than FGSM) is to apply multiple and smaller updates to the input in the direction of the local sign-gradients. This can be done by taking small steps of size $k \\leq \\lambda$ in the direction of the sign-gradient at the updated point and ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/2a4e319afc1606eccb7edab10c6f47fd3354fcf721ff055794c029e2134e683f.jpg",
+        "image_caption": [
+            "Figure 6: Accuracy plots of adversarial attacks, with different perturbation strengths, $\\lambda$ . The legend shows defender vs. adversary models (used for gradient computation), and the number of MC samples used to estimate the gradient. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            403,
+            109,
+            591,
+            219
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "repeating the procedure $\\lceil \\frac { \\lambda } { k } \\rceil$ times (Kurakin et al., 2016) as follows ",
+        "bbox": [
+            173,
+            303,
+            614,
+            320
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eebfe1df13b0f46fef852e4b82bc49a6400c438028c1651185980af9553660bb.jpg",
+        "text": "$$\nx ^ { 0 } = x \\mathrm { ~ , ~ } \\quad \\quad x ^ { t } = c l i p _ { x , \\lambda } \\left( x ^ { t - 1 } + k \\mathrm { s i g n } ( \\mathcal { I } ( \\theta , x ^ { t - 1 } , y ) ) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            328,
+            697,
+            348
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "where function $c l i p _ { x , \\lambda }$ is a projection into a $L _ { \\infty }$ -ball of radius $\\lambda$ centered at $x$ , and also into the hyper-cube of image space (each pixel is clipped to the range of $[ 0 , 2 5 5 ] ,$ ). The dense and SAP-100 models are tested against this adversarial attack, with $k = 1 . 0$ (Fig. 1c). The accuracies of the dense model at $\\lambda = 0$ , 1, 2 and 4 are $8 9 . 8 \\%$ , $6 6 . 3 \\%$ , $5 0 . 1 \\%$ and $3 1 . 0 \\%$ respectively. The accuracies of the SAP-100 model against attacks computed on the same model (with $1 0 \\mathrm { M C }$ samples taken at each step to estimate the gradient) are $8 3 . 3 \\%$ , $8 2 . 0 \\%$ , $8 0 . 2 \\%$ and $7 6 . 7 \\%$ , for $\\lambda = 0 , 1 , 2 , 4$ respectively. The SAP-100 model provides accuracies of $8 3 . 3 \\%$ , $7 5 . 2 \\%$ , $6 7 . 0 \\%$ and $5 0 . 8 \\%$ , against attacks computed on the dense model, with the perturbations $\\lambda = 0 , 1 , 2 , 4$ respectively. Iterative attacks on the SAP models are much more expensive to compute and noisier than iterative attacks on dense models. This is why the adversarial attack computed on the dense model results in lower accuracies on the SAP-100 model than the adversarial attack computed on the SAP-100 model itself. ",
+        "bbox": [
+            173,
+            373,
+            826,
+            529
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            551,
+            339,
+            566
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Robustness to adversarial attack has recently emerged as a serious topic in machine learning (Goodfellow et al., 2014; Kurakin et al., 2016; Papernot & McDaniel, 2016; Tramèr et al., 2017b; Fawzi et al., 2018). Goodfellow et al. (2014) introduced FGSM. Kurakin et al. (2016) proposed an iterative method where FGSM is used for smaller step sizes, which leads to a better approximation of the gradient. Papernot et al. (2017) observed that adversarial examples could be transferred to other models as well. Madry et al. (2017) introduce adding random noise to the image and then using the FGSM method to come up with adversarial examples. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            681
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Being robust against adversarial examples has primarily focused on training on the adversarial examples. Goodfellow et al. (2014) use FGSM to inject adversarial examples into their training dataset. Madry et al. (2017) use an iterative FGSM approach to create adversarial examples to train on. Tramèr et al. (2017a) introduced an ensemble adversarial training method of training on the adversarial examples created on the model itself and an ensemble of other pre-trained models. These works have been successful, achieving only a small drop in accuracy form the clean and adversarially generated data. Nayebi & Ganguli (2017) proposes a method to produce a smooth input-output mapping by using saturating activation functions and causing the activations to become saturated. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            800
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            821,
+            318,
+            838
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The SAP approach guards networks against adversarial examples without requiring any additional training. We showed that in the adversarial setting, applying SAP to image classifiers improves both the accuracy and calibration. Notably, combining SAP with adversarial training yields additive benefits. Additional experiments show that SAP can also be effective against adversarial examples in reinforcement learning. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vahid Behzadan and Arslan Munir. Vulnerability of deep reinforcement learning to policy induction attacks. arXiv preprint arXiv:1701.04143, 2017. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. J. Artif. Intell. Res.(JAIR), 47:253–279, 2013. ",
+        "bbox": [
+            176,
+            165,
+            823,
+            207
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tianqi Chen, Mu Li, Yutian Li, Min Lin, Naiyan Wang, Minjie Wang, Tianjun Xiao, Bing Xu, Chiyuan Zhang, and Zheng Zhang. Mxnet: A flexible and efficient machine learning library for heterogeneous distributed systems. arXiv preprint arXiv:1512.01274, 2015. ",
+        "bbox": [
+            174,
+            217,
+            823,
+            261
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alhussein Fawzi, Omar Fawzi, and Pascal Frossard. Analysis of classifiers’ robustness to adversarial perturbations. Machine Learning, 107(3):481–508, 2018. ",
+        "bbox": [
+            173,
+            270,
+            821,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014. ",
+        "bbox": [
+            174,
+            309,
+            823,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q Weinberger. On calibration of modern neural networks. arXiv preprint arXiv:1706.04599, 2017. ",
+        "bbox": [
+            176,
+            348,
+            823,
+            377
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015. ",
+        "bbox": [
+            173,
+            386,
+            825,
+            416
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            174,
+            426,
+            825,
+            468
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sandy Huang, Nicolas Papernot, Ian Goodfellow, Yan Duan, and Pieter Abbeel. Adversarial attacks on neural network policies. arXiv preprint arXiv:1702.02284, 2017. ",
+        "bbox": [
+            171,
+            478,
+            825,
+            508
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jernej Kos and Dawn Song. Delving into adversarial attacks on deep policies. arXiv preprint arXiv:1705.06452, 2017. ",
+        "bbox": [
+            171,
+            517,
+            825,
+            546
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            171,
+            556,
+            825,
+            573
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016. ",
+        "bbox": [
+            174,
+            580,
+            823,
+            611
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            174,
+            619,
+            826,
+            662
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. ",
+        "bbox": [
+            174,
+            672,
+            826,
+            715
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aran Nayebi and Surya Ganguli. Biologically inspired protection of deep networks from adversarial attacks. arXiv preprint arXiv:1703.09202, 2017. ",
+        "bbox": [
+            173,
+            726,
+            823,
+            755
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin J Osborne and Ariel Rubinstein. A course in game theory. MIT press, 1994. ",
+        "bbox": [
+            174,
+            763,
+            722,
+            780
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot and Patrick McDaniel. On the effectiveness of defensive distillation. arXiv preprint arXiv:1607.05113, 2016. ",
+        "bbox": [
+            169,
+            790,
+            823,
+            819
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the 2017 ACM on Asia Conference on Computer and Communications Security, pp. 506–519. ACM, 2017. ",
+        "bbox": [
+            176,
+            828,
+            825,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of machine learning research, 15(1):1929–1958, 2014. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramèr, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick McDaniel. Ensemble adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017a. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramèr, Nicolas Papernot, Ian Goodfellow, Dan Boneh, and Patrick McDaniel. The space of transferable adversarial examples. arXiv preprint arXiv:1704.03453, 2017b. ",
+        "bbox": [
+            173,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A REINFORCEMENT LEARNING MODEL ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            650,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For the experiments in section 4.2, we trained the network with RMSProp, minibatches of size 32, a learning rate of 0.00025, and a momentum of 0.95 and as in (Mnih et al., 2015) where the discount factor is $\\gamma = 0 . 9 9$ , the number of steps between target updates to 10000 steps. We updated the network every 4 steps by randomly sampling a minibatch of size 32 samples from the replay buffer and trained the agents for a total of $1 0 0 M$ steps per game. The experience replay contains the $1 M$ most recent transitions. For training we used an $\\varepsilon$ -greedy policy with $\\varepsilon$ annealed linearly from 1 to 0.1 over the first $1 M$ time steps and fixed at 0.1 thereafter. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            232
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The input to the network is $4 \\times 8 4 \\times 8 4$ tensor with a rescaled, gray-scale version of the last four observations. The first convolution layer has 32 filters of size 8 with a stride of 4. The second convolution layer has 64 filters of size 4 with stride 2. The last convolution layer has 64 filters of size 3 followed by two fully connected layers with size 512 and the final fully connected layer Q-value of each action where ReLU rectifier is deployed for the nonlinearity at each layer. ",
+        "bbox": [
+            174,
+            238,
+            825,
+            309
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B OTHER METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            330,
+            354,
+            347
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We tried a variety of different methods that could be added to pretrained models and tested their performance against adversarial examples. The following is a continuation of section 4.1, where we use the dense model again on the CIFAR-10 dataset. ",
+        "bbox": [
+            174,
+            362,
+            825,
+            405
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.1 RANDOM NOISY WEIGHTS (RNW) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            422,
+            455,
+            436
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "One simple way of introducing stochasticity to the activations is by adding random Gaussian noise to each weight, with mean 0 and constant standard deviation, s. So each weight tensor $W ^ { i }$ now changes to $M ( W ^ { i } )$ , where the $j$ ’th entry is given by ",
+        "bbox": [
+            174,
+            449,
+            825,
+            491
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5e8107bed76f8e779e514789b2829d6e96c487f6c53eeb8f9ec79a90e2ef493a.jpg",
+        "text": "$$\nM ( W ^ { i } ) _ { j } = ( W ^ { i } ) _ { j } + \\eta , \\qquad \\eta \\sim \\mathcal { N } ( 0 , s ^ { 2 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            498,
+            694,
+            518
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "These models behave very similar to the dense model (Fig. 5a, the legend indicates the value of $s$ ). While we test several different values of $s$ , we do not observe any significant improvements regarding robustness against adversarial examples. As $s$ increased, the accuracy for non-zero $\\lambda$ decreased. ",
+        "bbox": [
+            174,
+            532,
+            826,
+            575
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.2 RANDOMLY SCALED WEIGHTS (RSW) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            593,
+            482,
+            608
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Instead of using additive noise, we also try multiplicative noise. The scale factor can be picked from a Gaussian distribution, with mean 1 and constant standard deviation s. So each weight tensor $W ^ { i }$ now changes to $M ( W ^ { i } )$ , where the $j$ ’th entry is given by ",
+        "bbox": [
+            174,
+            619,
+            825,
+            662
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b43db97452227bc76a743b485efa2f6d8efcd14c2b873ea1f950524a83448f01.jpg",
+        "text": "$$\nM ( W ^ { i } ) _ { j } = \\eta \\cdot ( W ^ { i } ) _ { j } , \\qquad \\eta \\sim { \\mathcal { N } } ( 1 , s ^ { 2 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            670,
+            691,
+            690
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "These models perform similar to the dense model, but again, no robustness is offered against adversarial examples. They follow a similar trend as the RNW models (Figure 5b, the legend indicates the value of $s$ ). ",
+        "bbox": [
+            174,
+            704,
+            825,
+            747
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.3 DETERMINISTIC WEIGHT PRUNING (DWP) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            763,
+            513,
+            779
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Following from the motivation of preventing perturbations to propagate forward in the network, we tested deterministic weight pruning, where the top $k \\%$ entries of a weight matrix were kept, while the rest were pruned to 0, according to their absolute values. This method was prompted by the success achieved by this pruning method, introduced by Han et al. (2015), where they also fine-tuned the model. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            861
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For low levels of pruning, these models do very similar to the dense model, even against adversarial examples (Fig. 5c, the legend indicates the value of $k$ ). The adversary can compute the gradient of the sparse model, and the perturbations propagate forward through the surviving weights. For higher levels of sparsity, the accuracy in the no-perturbation case drops down quickly. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.4 STOCHASTIC WEIGHT PRUNING (SWP) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            486,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Observing the failure of deterministic weight pruning, we tested a mix of stochasticity and pruning, the stochastic weight pruning method. Very similar to the idea of SAP, we consider all the entries of a weight tensor to be a multinomial distribution, and we sample from it with replacement. For a weight tensor $W ^ { i } \\in \\mathbb { R } ^ { a ^ { i } }$ , we sample from it $r ^ { i }$ times with replacement. The probability of sampling $( W ^ { \\bar { i } } ) _ { j }$ is given by ",
+        "bbox": [
+            173,
+            128,
+            826,
+            203
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b9c84f60fc1ad30dc96c562ea9118e10c55fbb0e9a11cc57ac5c7d959dc2d085.jpg",
+        "text": "$$\np _ { j } ^ { i } = \\frac { | ( W ^ { i } ) _ { j } | } { \\sum _ { k = 1 } ^ { a ^ { i } } | ( W ^ { i } ) ) _ { k } | } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            209,
+            575,
+            250
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The new weight entry, $M ( W ^ { i } ) _ { j }$ , is given by ",
+        "bbox": [
+            174,
+            255,
+            465,
+            271
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/610a0989b3e78b905d5e845d65db8f28b8a032de3ce76b4704260efcfa13c9c5.jpg",
+        "text": "$$\nM ( W ^ { i } ) _ { j } = W _ { j } ^ { i } \\cdot \\frac { \\mathbb { I } ( W _ { j } ^ { i } ) } { 1 - ( 1 - p _ { i } ) ^ { r ^ { i } } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            277,
+            609,
+            315
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { I } ( W _ { j } ^ { i } )$ is the indicator function that returns 1 if $W _ { j } ^ { i }$ was sampled at least once, and 0 otherwise. ",
+        "bbox": [
+            174,
+            321,
+            825,
+            338
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For these experiments, for each weight matrix $W ^ { i } \\in \\mathbb { R } ^ { m ^ { i } }$ , the number of samples picked were $k \\%$ of $m ^ { i }$ . Since samples were picked with replacement, $k$ could be more than 100. We will refer to $k$ as the percentage of samples drawn. ",
+        "bbox": [
+            173,
+            347,
+            826,
+            391
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "These models behave very similar to the dense model. We tried drawing range of percentages of samples, but no evident robustness could be seen against adversarial examples (Figure 5d, the legend indicates the value of $k$ ). For a small $s$ , it is very similar to the dense model. As $s$ increases, the these models do marginally better for low non-zero $\\lambda$ values, and then drops again (similar to the SAP case). ",
+        "bbox": [
+            173,
+            397,
+            825,
+            468
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.5 RANDOM NOISY ACTIVATIONS (RNA) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            484,
+            480,
+            500
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Next we change our attention to the activation maps in the dense model. One simple way of introducing stochasticity to the activations is by adding random Gaussian noise to each activation entry, with mean 0 and constant standard deviation, $s$ . So each activation map $h ^ { i }$ now changes to $M ( h ^ { i } )$ , where the $j ^ { : }$ ’th entry is given by ",
+        "bbox": [
+            173,
+            511,
+            825,
+            568
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b9accd50bc8228f9359e983aef3666dd387e72b3768e2dca502392ad7b883533.jpg",
+        "text": "$$\nM ( h ^ { i } ) _ { j } = ( h ^ { i } ) _ { j } + \\eta , \\qquad \\eta \\sim \\mathcal { N } ( 0 , s ^ { 2 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            573,
+            689,
+            593
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "These models too do not offer any robustness against adversarial examples. Their accuracy drops quickly with $\\lambda$ and $s$ (Fig. 5e, the legend indicates the value of $s$ ). ",
+        "bbox": [
+            173,
+            606,
+            823,
+            636
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.6 RANDOMLY SCALED ACTIVATIONS (RSA) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            651,
+            508,
+            667
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Instead of having additive noise, we can also make the model stochastic by scaling the activations. The scale factor can be picked from a Gaussian distribution, with mean 1 and constant standard deviation $s$ . So each activation map $h ^ { i }$ now changes to $M ( h ^ { i } )$ , where the $j$ ’th entry is given by ",
+        "bbox": [
+            173,
+            678,
+            826,
+            722
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/26c9385a3a0e52679ad538a4db6084d4ce0a64712698d8a2b59215ee071bcc73.jpg",
+        "text": "$$\nM ( h ^ { i } ) _ { j } = \\eta ( h ^ { i } ) _ { j } , \\qquad \\eta \\sim { \\mathcal { N } } ( 1 , s ^ { 2 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            727,
+            681,
+            747
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "These models perform similar to the dense model, exhibiting no additional robustness against adversarial examples (Figure 5f, the legend indicates the value of $s$ ). ",
+        "bbox": [
+            173,
+            760,
+            825,
+            790
+        ],
+        "page_idx": 12
+    }
+]

parse/train/HJDBUF5le/HJDBUF5le.md

@@ -0,0 +1,312 @@
+# TOWARDS A NEURAL STATISTICIAN
+
+# Amos Storkey
+
+Harrison Edwards   
+School of Informatics   
+University of Edinburgh   
+Edinburgh, UK   
+H.L.Edwards@sms.ed.ac.uk
+
+School of Informatics University of Edinburgh Edinburgh, UK A.Storkey@ed.ac.uk
+
+# ABSTRACT
+
+An efficient learner is one who reuses what they already know to tackle a new problem. For a machine learner, this means understanding the similarities amongst datasets. In order to do this, one must take seriously the idea of working with datasets, rather than datapoints, as the key objects to model. Towards this goal, we demonstrate an extension of a variational autoencoder that can learn a method for computing representations, or statistics, of datasets in an unsupervised fashion. The network is trained to produce statistics that encapsulate a generative model for each dataset. Hence the network enables efficient learning from new datasets for both unsupervised and supervised tasks. We show that we are able to learn statistics that can be used for: clustering datasets, transferring generative models to new datasets, selecting representative samples of datasets and classifying previously unseen classes. We refer to our model as a neural statistician, and by this we mean a neural network that can learn to compute summary statistics of datasets without supervision.
+
+# 1 INTRODUCTION
+
+The machine learning community is well-practised at learning representations of data-points and sequences. A middle-ground between these two is representing, or summarizing, datasets - unordered collections of vectors, such as photos of a particular person, recordings of a given speaker or a document as a bag-of-words. Where these sets take the form of i.i.d samples from some distribution, such summaries are called statistics. We explore the idea of using neural networks to learn statistics and we refer to our approach as a neural statistician.
+
+The key result of our approach is a statistic network that takes as input a set of vectors and outputs a vector of summary statistics specifying a generative model of that set - a mean and variance specifying a Gaussian distribution in a latent space we term the context. The advantages of our approach are that it is:
+
+• Unsupervised: It provides principled and unsupervised way to learn summary statistics as the output of a variational encoder of a generative model.   
+• Data efficient: If one has a large number of small but related datasets, modelling the datasets jointly enables us to gain statistical strength.   
+• Parameter Efficient: By using summary statistics instead of say categorical labellings of each dataset, we decouple the number of parameters of the model from the number of datasets.   
+• Capable of few-shot learning: If the datasets correspond to examples from different classes, class embeddings (summary statistics associated with examples from a class), allow us to handle new classes at test time.
+
+# 2 PROBLEM STATEMENT
+
+We are given datasets $D _ { i }$ for $i \in \mathcal { Z }$ . Each dataset $D _ { i } = \{ x _ { 1 } , \ldots , x _ { k _ { i } } \}$ consists of a number of i.i.d samples from an associated distribution $p _ { i }$ over $\mathbb { R } ^ { n }$ . The task can be split into learning and inference components. The learning component is to produce a generative model $\hat { p } _ { i }$ for each dataset $D _ { i }$ . We assume there is a common underlying generative process $p$ such that $p _ { i } = p ( \cdot | c _ { i } )$ for $c _ { i } \in \mathbb { R } ^ { l }$ drawn from $p ( c )$ . We refer to $c$ as the context. The inference component is to give an approximate posterior over the context $q ( c | D )$ for a given dataset produced by a statistic network.
+
+# 3 NEURAL STATISTICIAN
+
+In order to exploit the assumption of a hierarchical generative process over datasets we will use a ‘parameter-transfer approach’ (see Pan & Yang, 2010) to extend the variational autoencoder model of Kingma & Welling (2013).
+
+![](images/6e6de22e59acbd630cacaf80d1e1542ac5d29c3f4627ec81e0775900d79c83d2.jpg)  
+Figure 1: Left: basic hierarchical model, where the plate encodes the fact that the context variable $c$ is shared across each item in a given dataset. Center: full neural statistician model with three latent layers $z _ { 1 } , z _ { 2 } , z _ { 3 }$ . Each collection of incoming edges to a node is implemented as a neural network, the input of which is the concatenation of the edges’ sources, the output of which is a parameterization of a distribution over the random variable represented by that node. Right: The statistic network, which combines the data via an exchangeable statistic layer.
+
+# 3.1 VARIATIONAL AUTOENCODER
+
+The variational autoencoder is a latent variable model $p ( x | z ; \theta )$ (often called the decoder) with parameters $\theta$ . For each observed $x$ , a corresponding latent variable $z$ is drawn from $p ( z )$ so that
+
+$$
+p ( x ) = \int p ( x | z ; \theta ) p ( z ) d z .
+$$
+
+The generative parameters $\theta$ are learned by introducing a recognition network (also called an encoder) $q ( z | x ; \phi )$ with parameters $\phi$ . The recognition network gives an approximate posterior over the latent variables that can then be used to give the standard variational lower bound (Saul & Jordan, 1996) on the single-datum log-likelihood. I.e. $\log P ( x | \theta ) \geq \mathcal { L } _ { x }$ , where
+
+$$
+\mathcal { L } _ { x } = \mathbb { E } _ { q ( z | x , \phi ) } \left[ \log p ( x | z ; \theta ) \right] - D _ { K L } \left( q ( z | x ; \phi ) \| p ( z ) \right) .
+$$
+
+Likewise the full-data log likelihood is lower bounded by the sum of the ${ \mathcal { L } } _ { x }$ terms over the whole dataset. We can then optimize this lower bound with respect to $\phi$ and $\theta$ using the reparameterization trick introduced by Kingma & Welling (2013) and Rezende et al. (2014) to get a Monte-Carlo estimate of the gradient.
+
+# 3.2 BASIC MODEL
+
+We extend the variational autoencoder to the model depicted on the left in Figure 1. This includes a latent variable $c$ , the context, that varies between different datasets but is constant, a priori, for items within the same dataset. Now, the likelihood of the parameters $\theta$ for one single particular dataset $D$ is given by
+
+$$
+p ( D ) = \int p ( c ) \left[ \prod _ { x \in D } \int p ( x | z ; \theta ) p ( z | c ; \theta ) d z \right] d c .
+$$
+
+The prior $p ( c )$ is chosen to be a spherical Gaussian with zero mean and unit variance. The conditional $p ( z | c ; \theta )$ is Gaussian with diagonal covariance, where all the mean and variance parameters depend on $c$ through a neural network. Similarly the observation model $p ( x | z ; \theta )$ will be a simple likelihood function appropriate to the data modality with dependence on $z$ parameterized by a neural network. For example, with real valued data, a diagonal Gaussian likelihood could be used where the mean and log variance of $x$ are created from $z$ via a neural network.
+
+We use approximate inference networks $q ( \boldsymbol { z } | \boldsymbol { x } , c ; \phi )$ , $q ( c | D ; \phi )$ , with parameters collected into $\phi$ , to once again enable the calculation and optimization of a variational lower bound on the loglikelihood. The single dataset log likelihood lower bound is given by
+
+$$
+\begin{array}{c} \mathcal { L } _ { D } = \mathbb { E } _ { q ( c | D ; \phi ) } \left[ \sum _ { x \in d } \mathbb { E } _ { q ( z | c , x ; \phi ) } \left[ \log p ( x | z ; \theta ) \right] - D _ { K L } \left( q ( z | c , x ; \phi ) \| p ( z | c ; \theta ) \right) \right]  \\ & { \phantom { = \ } - D _ { K L } \left( q ( c | D ; \phi ) \| p ( c ) \right) . } \end{array}
+$$
+
+As with the generative distributions, the likelihood forms for $q ( \boldsymbol { z } | \boldsymbol { x } , c ; \phi )$ and $q ( c | D ; \phi )$ are diagonal Gaussian distributions, where all the mean and log variance parameters in each distribution are produced by a neural network taking the conditioning variables as inputs. Note that $q ( c | D ; \phi )$ accepts as input a dataset $D$ and we refer to this as the statistic network. We describe this in Subsection 3.4.
+
+The full-data variational bound is given by summing the variational bound for each dataset in our collection of datasets. It is by learning the difference of the within-dataset and between-dataset distributions that we are able to discover an appropriate statistic network.
+
+# 3.3 FULL MODEL
+
+The basic model works well for modelling simple datasets, but struggles when the datasets have complex internal structure. To increase the sophistication of the model we use multiple stochastic layers $z _ { 1 } , \ldots , z _ { k }$ and introduce skip-connections for both the inference and generative networks. The generative model is shown graphically in Figure 1 in the center. The probability of a dataset $D$ is then given by
+
+$$
+p ( D ) = \int p ( c ) \prod _ { x \in D } \int p ( x | c , z _ { 1 : L } ; \theta ) p ( z _ { L } | c ; \theta ) \prod _ { i = 1 } ^ { L - 1 } p ( z _ { i } | z _ { i + 1 } , c ; \theta ) d z _ { 1 : L } d c
+$$
+
+where the $p ( z _ { i } | z _ { i + 1 } , c , \theta )$ are again Gaussian distributions where the mean and log variance are given as the output of neural networks. The generative process for the full model is described in Algorithm 1.
+
+The full approximate posterior factorizes analogously as
+
+$$
+q ( c , z _ { 1 : L } | D ; \phi ) = q ( c | D ; \phi ) \prod _ { x \in D } q ( z _ { L } | x , c ; \phi ) \prod _ { i = 1 } ^ { L - 1 } q ( z _ { i } | z _ { i + 1 } , x , c ; \phi ) .
+$$
+
+For convenience we give the variational lower bound as sum of a three parts, a reconstruction term $R _ { D }$ , a context divergence $C _ { D }$ and a latent divergence $L _ { D }$ :
+
+$$
+\begin{array} { l } { \displaystyle R _ { D } = \mathbb { E } _ { q ( c | D ; \phi ) } \sum _ { x \in D } \mathbb { E } _ { q ( z _ { 1 : L } | c , x ; \phi ) } \log p ( x | z _ { 1 : L } , c ; \theta ) } \\ { \displaystyle C _ { D } = D _ { K L } \left( q ( c | D ; \phi ) \| p ( c ) \right) } \\ { \displaystyle L _ { D } = \mathbb { E } _ { q ( c , z _ { 1 : L } | D ; \phi ) } \left[ \displaystyle \sum _ { x \in D } D _ { K L } \left( q ( z _ { L } | c , x ; \phi ) \| p ( z _ { L } | c ; \theta ) \right) \right. } \\ { \displaystyle \left. \qquad \quad + \displaystyle \sum _ { i = 1 } ^ { L - 1 } D _ { K L } \left( q ( z _ { i } | z _ { i + 1 } , c , x ; \phi ) \| p ( z _ { i } | z _ { i + 1 } , c ; \theta ) \right) \right] . } \end{array}
+$$
+
+The skip-connections $p ( z _ { i } | z _ { i + 1 } , c ; \theta )$ and $q ( z _ { i } | z _ { i + 1 } , x ; \phi )$ allow the context to specify a more precise distribution for each latent variable by explaining-away more generic aspects of the dataset at each stochastic layer. This architecture was inspired by recent work on probabilistic ladder networks in Kaae Sønderby et al. (2016). Complementing these are the skip-connections from each latent variable to the observation $p ( x | z _ { 1 : L } , c ; \theta )$ , the intuition here is that each stochastic layer can focus on representing a certain level of abstraction, since its information does not need to be copied into the next layer, a similar approach was used in Maaløe et al. (2016).
+
+Once again, note that we are maximizing the lower bound to the log likelihood over many datasets $D$ : we want to maximize the expectation of $\mathcal { L } _ { D }$ over all datasets. We do this optimization using stochastic gradient descent. In contrast to a variational autoencoder where a minibatch would consist of a subsample of datapoints from the dataset, we use minibatches consisting of a subsample of datasets - tensors of shape (batch size, sample size, number of features).
+
+# 3.4 STATISTIC NETWORK
+
+In addition to the standard inference networks we require a statistic network $q ( c | D ; \phi )$ to give an approximate posterior over the context $c$ given a dataset $D = \{ x _ { 1 } , \ldots , x _ { k } \}$ . This inference network must capture the exchangeability of the data in $D$ .
+
+We use a feedforward neural network consisting of three main elements:
+
+• An instance encoder $E$ that takes each individual datapoint $x _ { i }$ to a vector $e _ { i } = E ( x _ { i } )$ . • An exchangeable instance pooling layer that collapses the matrix $( e _ { 1 } , \ldots , e _ { k } )$ to a single pre-statistic vector $v$ . Examples include elementwise means, sums, products, geometric means and maximum. We use the sample mean for all experiments. • A final post-pooling network that takes $v$ to a parameterization of a diagonal Gaussian.
+
+The graphical model for this is given at the right of Figure 1.
+
+We note that the humble sample mean already gives the statistic network a great deal of representational power due to the fact that the instance encoder can learn a representation where averaging makes sense. For example since the instance encoder can approximate a polynomial on a compact domain, and so can the post-pooling network, a statistic network can approximate any moment of a distribution.
+
+# 4 RELATED WORK
+
+Due to the general nature of the problem considered, our work touches on many different topics which we now attempt to summarize.
+
+Topic models and graphical models The form of the graphical model in Figure 1 on the left is equivalent to that of a standard topic model. In contrast to traditional topic models we do not use discrete latent variables, or restrict to discrete data. Work such as that by Ranganath et al. (2014) has extended topic models in various directions, but importantly we use flexible conditional distributions and dependency structures parameterized by deep neural networks. Recent work has explored neural networks for document models (see e.g. Miao et al., 2015) but has been limited to modelling datapoints with little internal structure. Along related lines are ‘structured variational autoencoders’ (see Johnson et al., 2016), where they treat the general problem of integrating graphical models with variational autoencoders.
+
+Transfer learning There is a considerable literature on transfer learning, for a survey see Pan & Yang (2010). There they discuss ‘parameter-transfer’ approaches whereby parameters or priors are shared across datasets, and our work fits into that paradigm. For examples see Lawrence & Platt (2004) where share they priors between Gaussian processes, and Evgeniou & Pontil (2004) where they take an SVM-like approach to share kernels.
+
+One-shot Learning Learning quickly from small amounts of data is a topic of great interest. Lake et al. (2015) use Bayesian program induction for one-shot generation and classification, and Koch (2015) train a Siamese (Chopra et al. (2005)) convolutional network for one-shot image classification. We note the relation to the recent work (Rezende et al., 2016) in which the authors use a conditional recurrent variational autoencoder capable of one-shot generalization by taking as extra input a conditioning data point. The important differences here are that we jointly model datasets and datapoints and consider datasets of any size. Recent approaches to one-shot classification are matching networks (Vinyals et al., 2016b) (which was concurrent with the initial preprint of this work), and related previous work (Santoro et al., 2016). The former can be considered a kind of differentiable nearest neighbour classifier, and the latter augments their network with memory to store information about the classification problem. Both are trained end-to-end for the classification problem, whereas the present work is a general approach to learning representations of datasets. Probably the closest previous work is by Salakhutdinov et al. (2012) where the authors learn a topic model over the activations of a DBM for one-shot learning. Compared with their work we use modern architectures and easier to train VAEs, in particular we have fast and amortized feedforward inference for test (and training) datasets, avoiding the need for MCMC.
+
+Multiple-Instance Learning There is previous work on classifying sets in multiple-instance learning, for a useful survey see Cheplygina et al. (2015). Typical approaches involve adapting kernel based methods such as support measure machines (Muandet et al., 2012), support distribution machines (Poczos et al., 2012) and ´ multiple-instance-kernels (Gartner et al., 2002). We do not consider applications to multiple-instance learning type problems here, but it may be fruitful to do so in the future.
+
+Set2Seq In very related work, Vinyals et al. (2016a) explore architectures for mapping sets to sequences. There they use an LSTM to repeatedly compute weighted-averages of the datapoints and use this to tackle problems such as sorting a list of numbers. The main difference between their work and ours is that they primarily consider supervised problems, whereas we present a general unsupervised method for learning representations of sets of i.i.d instances. In future work we may also explore recurrently computing statistics.
+
+ABC There has also been work on learning summary statistics for Approximate Bayesian Computation by either learning to predict the parameters generating a sample as a supervised problem, or by using kernel embeddings as infinite dimensional summary statistics. See the work by Fukumizu et al. (2013) for an example of kernel-based approaches. More recently Jiang et al. (2015) used deep neural networks to predict the parameters generating the data. The crucial differences are that their problem is supervised, they do not leverage any exchangeability properties the data may have, nor can it deal with varying sample sizes.
+
+# 5 EXPERIMENTAL RESULTS
+
+Given an input set $x _ { 1 } , \ldots x _ { k }$ we can use the statistic network to calculate an approximate posterior over contexts $q ( c | x _ { 1 } , \ldots , x _ { k } ; \phi )$ . Under the generative model, each context $c$ specifies a conditional model $p ( x | c ; \bar { \theta } )$ . To get samples from the model corresponding to the most likely posterior value of $c$ , we set $c$ to the mean of the approximate posterior and then sample directly from the conditional distributions. This is described in Algorithm 2. We use this process in our experiments to show samples. In all experiments, we use the Adam optimization algorithm (Kingma & Ba, 2014) to optimize the parameters of the generative models and variational approximations. Batch normalization (Ioffe & Szegedy, 2015) is implemented for convolutional layers and we always use a batch size of 16. We primarily use the Theano (Theano Development Team, 2016) framework with the Lasagne (Dieleman et al., 2015) library, but the final experiments with face data were done using Tensorflow (Abadi et al., 2015). In all cases experiments were terminated after a given number of epochs when training appeared to have sufficiently converged (300 epochs for omniglot, youtube and spatial MNIST examples, and 50 epochs for the synthetic experiment).
+
+# 5.1 SIMPLE 1-D DISTRIBUTIONS
+
+In our first experiment we wanted to know if the neural statistician will learn to cluster synthetic 1-D datasets by distribution family. We generated a collection of synthetic 1-D datasets each containing 200 samples. Datasets consist of samples from either an Exponential, Gaussian, Uniform or Laplacian distribution with equal probability. Means and variances are sampled from $U [ - 1 , 1 ]$ and $U [ \bar { 0 } . 5 , 2 ]$ respectively. The training data contains $1 0 K$ sets.
+
+The architecture for this experiment contains a single stochastic layer with 32 units for $z$ and 3 units for $c _ { \cdot }$ , . The model $p ( \boldsymbol { x } | \boldsymbol { z } , c ; \boldsymbol { \theta } )$ and variational approximation $\dot { q ( \boldsymbol { z } | \boldsymbol { x } , \boldsymbol { c } ; \boldsymbol { \phi } ) }$ are each a diagonal Gaussian distribution with all mean and log variance parameters given by a network composed of three dense layers with ReLU activations and 128 units. The statistic network determining the mean and log variance parameters of posterior over context variables is composed of three dense layers before and after pooling, each with 128 units with Rectified Linear Unit (ReLU) activations.
+
+Figure 2 shows 3-D scatter plots of the summary statistics learned. Notice that the different families of distribution cluster. It is interesting to observe that the Exponential cluster is differently orientated to the others, perhaps reflecting the fact that it is the only non-symmetric distribution. We also see that between the Gaussian and Laplacian clusters there is an area of ambiguity which is as one might expect. We also see that within each cluster the mean and variance are mapped to orthogonal directions.
+
+![](images/e82aa8476b90fc3fe6c80a77c4987d5d4f95485cd667e79fb1c7bdb8913f02e9.jpg)  
+Figure 2: Three different views of the same data. Each point is the mean of the approximate posterior over the context $q ( c | D ; \phi )$ where $c \in \mathbb { R } ^ { 3 }$ . Each point is a summary statistic for a single dataset with 200 samples. Top plot shows points colored by distribution family, left plot colored by the mean and right plot colored by the variance. The plots have been rotated to illustrative angles.
+
+# 5.2 SPATIAL MNIST
+
+Building on the previous experiments we investigate 2-D datasets that have complex structure, but the datapoints contain little information by themselves, making it a good test of the statistic network. We created a dataset called spatial MNIST. In spatial MNIST each image from MNIST (LeCun et al., 1998) is turned into a dataset by interpreting the normalized pixel intensities as a probability density and sampling coordinate values. An example is shown in Figure 3. This creates two-dimensional spatial datasets. We used a sample size of 50. Note that since the pixel coordinates are discrete, it is necessary to dequantize them by adding uniform noise $u \sim U [ 0 , 1 ]$ to the coordinates if one models them as real numbers, else you can get arbitrarily high densities (see Theis et al. (2016) for a discussion of this point).
+
+![](images/5260004343dab07772be2c07e4ccd346a980af8a90502f574063c61798f31e23.jpg)  
+Figure 3: An image from MNIST on the left, transformed to a set of 50 $( x , y )$ coordinates, shown as a scatter plot on the right.
+
+The generative architecture for this experiment contains 3 stochastic $z$ layers, each with 2 units, and a single $c$ layer with 64 units. The means and log variances of the Gaussian likelihood for $p ( x | z _ { 1 : 3 } , \bar { c } ; \theta )$ , and each subnetwork for $z$ in both the encoder and decoder contained 3 dense layers with 256 ReLU units each. The statistic network also contained 3 dense layers pre-pooling and 3 dense layers post pooling with 256 ReLU units.
+
+In addition to being able to sample from the model conditioned on a set of inputs, we can also summarize a dataset by choosing a subset $S \subseteq D$ to minimise the KL divergence of $q ( C | D ; \phi )$ from $q ( C | S ; \phi )$ . We do this greedily by iteratively discarding points from the full sample. Pseudocode for this process is given in Algorithm 3. The results are shown in Figure 4. We see that the model is capable of handling complex arrangements of datapoints. We also see that it can select sensible subsets of a dataset as a summary.
+
+# 5.3 OMNIGLOT
+
+Next we work with the OMNIGLOT data (Lake et al., 2015). This contains 1628 classes of handwritten characters but with just 20 examples per class. This makes it an excellent test-bed for transfer / few-shot learning. We constructed datasets by splitting each class into datasets of size 5. We train on datasets drawn from 1200 classes and reserve the remaining classes to test few-shot sampling and classification. We created new classes by rotating and reflecting characters. We resized the images to $2 8 \times 2 8$ . We sampled a binarization of each image for each epoch. We also randomly applied the dilation operator from computer vision as further data augmentation since we observed that the stroke widths are quite uniform in the OMNIGLOT data, whereas there is substantial variation in MNIST, this augmentation improved the visual quality of the few-shot MNIST samples considerably and increased the few-shot classification accuracy by about 3 percent. Finally we used ‘sample dropout’ whereby a random subset of each dataset was removed from the pooling in the statistic network, and then included the number of samples remaining as an extra feature. This was beneficial since it reduced overfitting and also allowed the statistic network to learn to adjust the approximate posterior over $c$ based on the number of samples.
+
+![](images/28105ff1bd0578e7f26caba92274867ed296cc4f906f44fda9289ea57607f180.jpg)  
+Figure 4: Conditioned samples from spatial MNIST data. Blue and red digits are the input sets, black digits above correspond to samples given the input. Red points correspond to a 6-sample summary of the dataset
+
+![](images/c4d7da7a84dd63fbee15ce45457934785ddee8a48d232a86fb352d939fe0c78a.jpg)  
+Figure 5: Few-shot learning Left: Few-shot learning from OMNIGLOT to MNIST. Left rows are input sets, right rows are samples given the inputs. Right: Few-shot learning from with OMNIGLOT data to unseen classes. Left rows are input sets, right rows are samples given the inputs. Black-white inversion is applied for ease of viewing.
+
+We used a single stochastic layer with 16 units for $z$ , and 512 units for $c$ . We used a shared convolutional encoder between the inference and statistic networks and a deconvolutional decoder network. Full details of the networks are given in Appendix B.1. The decoder used a Bernoulli likelihood.
+
+In Figure 5 we show two examples of few-shot learning by conditioning on samples of unseen characters from OMNIGLOT, and conditioning on samples of digits from MNIST. The samples are mostly of a high-quality, and this shows that the neural statistician can generalize even to new datasets.
+
+As a further test we considered few-shot classification of both unseen OMNIGLOT characters and MNIST digits. Given a sets of labelled examples of each class $D _ { 0 } , \ldots , D _ { 9 }$ (for MNIST say), we computed the approximate posteriors $q ( C | D _ { i } ; \phi )$ using the statistic network. Then for each test image $x$ we also computed the posterior $q ( C | x ; \phi )$ and classified it according to the training dataset $D _ { i }$ minimizing the KL divergence from the test context $t o$ the training context. This process is described in Algorithm 4. We tried this with either 1 or 5 labelled examples per class and either 5 or 20 classes. For each trial we randomly select $K$ classes, randomly select training examples for each class, and test on the remaining examples. This process is repeated 100 times and the results averaged. The results are shown in Table 1. We compare to a number of results reported in Vinyals et al. (2016b) including Santoro et al. (2016) and Koch (2015). Overall we see that the neural statistician model can be used as a strong classifier, particularly for the 5-way tasks, but performs worse than matching networks for the 20-way tasks. One important advantage that matching networks have is that, whilst each class is processed independently in our model, the representation in matching networks is conditioned on all of the classes in the few-shot problem. This means that it can exaggerate differences between similar classes, which are more likely to appear in a 20-way problem than a 5-way problem.
+
+<table><tr><td colspan="3">Task</td><td rowspan="2"></td><td colspan="3">Method</td></tr><tr><td>Test Dataset</td><td>K Shot</td><td>K Way</td><td>Siamese</td><td>MANN</td><td>Matching Ours</td></tr><tr><td>MNIST</td><td>1</td><td>10</td><td>70</td><td>=</td><td>72</td><td>78.6</td></tr><tr><td>MNIST</td><td>5</td><td>10</td><td>=</td><td>=</td><td>=</td><td>93.2</td></tr><tr><td>OMNIGLOT</td><td>1</td><td>5</td><td>97.3</td><td>82.8</td><td>98.1</td><td>98.1</td></tr><tr><td>OMNIGLOT</td><td>5</td><td>5</td><td>98.4</td><td>94.9</td><td>98.9</td><td>99.5</td></tr><tr><td>OMNIGLOT</td><td>1</td><td>20</td><td>88.1</td><td>-</td><td>93.8</td><td>93.2</td></tr><tr><td>OMNIGLOT</td><td>5</td><td>20</td><td>97.0</td><td>=</td><td>98.7</td><td>98.1</td></tr></table>
+
+Table 1: The table shows the classification accuracies of various few-shot learning tasks. Models are trained on OMNIGLOT data and tested on either unseen OMNIGLOT classes or MNIST with varying numbers of samples per class (K-shot) with varying numbers of classes (K-way). Comparisons are to Vinyals et al. (2016b) (Matching), Santoro et al. (2016) (MANN) and Koch (2015) (Siamese). 5-shot MNIST results are included for completeness.
+
+# 5.4 YOUTUBE FACES
+
+![](images/fafb5e74c2af1ea1f3189d1b879c5489693d5f0f55cb2ce7cdf8398d5995f5eb.jpg)  
+Figure 6: Few-shot learning for face data. Samples are from model trained on Youtube Faces Database. Left: Each row shows an input set of size 5. Center: Each row shows 5 samples from the model corresponding to the input set on the left. Right: Imagined new faces generated by sampling contexts from the prior. Each row consists of 5 samples from the model given a particular sampled context.
+
+Finally, we provide a proof of concept for generating faces of a particular person. We use the Youtube Faces Database from Wolf et al. (2011). It contains 3, 245 videos of 1, 595 different people. We use the aligned and cropped to face version, resized to $6 4 \times 6 4$ . The validation and test sets contain 100 unique people each, and there is no overlap of persons between data splits. The sets were created by sampling frames randomly without replacement from each video, we use a set size of 5 frames. We resample the sets for the training data each epoch.
+
+Our architecture for this problem is based on one presented in Lamb et al. (2016). We used a single stochastic layer with 500 dimensional latent $c$ and 16 dimensional $z$ variable. The statistic network and the inference network $q ( \boldsymbol { z } | \boldsymbol { x } , c ; \phi )$ share a common convolutional encoder, and the deocder uses deconvolutional layers. For full details see Appendix B.2. The likelihood function is a Gaussian, but where the variance parameters are shared across all datapoints, this was found to make training faster and more stable.
+
+The results are shown in Figure 6. Whilst there is room for improvement, we see that it is possible to specify a complex distribution on-the-fly with a set of photos of a previously unseen person. The samples conditioned on an input set have a reasonable likeness of the input faces. We also show the ability of the model to generate new datasets and see that the samples have a consistent identity and varied poses.
+
+# 6 CONCLUSION
+
+We have demonstrated a highly flexible model on a variety of tasks. Going forward our approach will naturally benefit from advances in generative models as we can simply upgrade our base generative model, and so future work will pursue this. Compared with some other approaches in the literature for few-shot learning, our requirement for supervision is weaker: we only ask at training time that we are given datasets, but we do not need labels for the datasets, nor even information on whether two datasets represent the same or different classes. It would be interesting then to explore application areas where only this weaker form of supervision is available. There are two important limitations to this work, firstly that the method is dataset hungry: it will likely not learn useful representations of datasets given only a small number of them. Secondly at test time the few-shot fit of the generative model will not be greatly improved by using larger datasets unless the model was also trained on similarly large datasets. The latter limitation seems like a promising future research direction - bridging the gap between fast adaptation and slow training.
+
+# ACKNOWLEDGMENTS
+
+This work was supported in part by the EPSRC Centre for Doctoral Training in Data Science, funded by the UK Engineering and Physical Sciences Research Council (grant EP/L016427/1) and the University of Edinburgh.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, and Zhifeng Chen et al. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow. org/. Software available from tensorflow.org.   
+Veronika Cheplygina, David M.J. Tax, and Marco Loog. On classification with bags, groups and sets. Pattern Recognition Letters, 59:11 – 17, 2015.   
+S. Chopra, R. Hadsell, and Y. LeCun. Learning a similarity metric discriminatively, with application to face verification. In Computer Vision and Pattern Recognition, 2005. CVPR 2005. IEEE Computer Society Conference on, pp. 539–546 Vol. 1, June 2005.   
+Sander Dieleman, Jan Schluter, Colin Raffel, Eben Olson, SK Sønderby, D Nouri, D Maturana, ¨ M Thoma, E Battenberg, J Kelly, et al. Lasagne: First release. Zenodo: Geneva, Switzerland, 2015.   
+Theodoros Evgeniou and Massimiliano Pontil. Regularized multi–task learning. In Proceedings of the tenth ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 109–117. ACM, 2004.   
+Kenji Fukumizu, Le Song, and Arthur Gretton. Kernel Bayes’ rule: Bayesian inference with positive definite kernels. The Journal of Machine Learning Research, 14(1):3753–3783, 2013.   
+Thomas Gartner, Peter A. Flach, Adam Kowalczyk, and Alex J. Smola. Multi-instance kernels. In In Proc. 19th International Conf. on Machine Learning, pp. 179–186. Morgan Kaufmann, 2002.   
+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, pp. 448–456, 2015.
+
+Bai Jiang, Tung-yu Wu, Charles Zheng, and Wing H Wong. Learning summary statistic for approximate Bayesian computation via deep neural network. arXiv preprint arXiv:1510.02175, 2015.
+
+Matthew J Johnson, David Duvenaud, Alexander B Wiltschko, Sandeep R Datta, and Ryan P Adams. Structured vaes: Composing probabilistic graphical models and variational autoencoders. arXiv preprint arXiv:1603.06277, 2016.
+
+Casper Kaae Sønderby, Tapani Raiko, Lars Maaløe, Søren Kaae Sønderby, and Ole Winther. How to train deep variational autoencoders and probabilistic ladder networks. arXiv preprint arXiv:1602.02282, 2016.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational Bayes. In Proceedings of the 2nd International Conference on Learning Representations (ICLR), number 2014, 2013.
+
+Gregory Koch. Siamese neural networks for one-shot image recognition. Doctoral dissertation, University of Toronto, 2015.
+
+Brenden M Lake, Ruslan Salakhutdinov, and Joshua B Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015.
+
+Alex Lamb, Vincent Dumoulin, and Aaron Courville. Discriminative regularization for generative models. arXiv preprint arXiv:1602.03220, 2016.
+
+Neil D Lawrence and John C Platt. Learning to learn with the informative vector machine. In Proceedings of the twenty-first international conference on Machine learning, pp. 65. ACM, 2004.
+
+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.
+
+Lars Maaløe, Casper Kaae Sønderby, Søren Kaae Sønderby, and Ole Winther. Auxiliary deep generative models. arXiv preprint arXiv:1602.05473, 2016.
+
+Yishu Miao, Lei Yu, and Phil Blunsom. Neural variational inference for text processing. arXiv preprint arXiv:1511.06038, 2015.
+
+Krikamol Muandet, Kenji Fukumizu, Francesco Dinuzzo, and Bernhard Schlkopf. Learning from distributions via support measure machines. In P. Bartlett, FCN. Pereira, CJC. Burges, L. Bottou, and KQ. Weinberger (eds.), Advances in Neural Information Processing Systems 25, pp. 10–18. 2012.
+
+Sinno Jialin Pan and Qiang Yang. A survey on transfer learning. Knowledge and Data Engineering, IEEE Transactions on, 22(10):1345–1359, 2010.
+
+Barnabas P ´ oczos, Liang Xiong, Dougal J Sutherland, and Jeff Schneider. Support distribution ma- ´ chines. Technical Report, 2012. URL http://arxiv.org/abs/1202.0302.
+
+Rajesh Ranganath, Sean Gerrish, and David M Blei. Black box variational inference. In AISTATS, pp. 814–822, 2014.
+
+Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Proceedings of The 31st International Conference on Machine Learning, pp. 1278–1286, 2014.
+
+Danilo Jimenez Rezende, Shakir Mohamed, Ivo Danihelka, Karol Gregor, and Daan Wierstra. Oneshot generalization in deep generative models. arXiv preprint arXiv:1603.05106, 2016.
+
+Ruslan Salakhutdinov, Joshua B Tenenbaum, and Antonio Torralba. One-shot learning with a hierarchical nonparametric bayesian model. In ICML Unsupervised and Transfer Learning, pp. 195–206, 2012.
+
+Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy Lillicrap. Oneshot learning with memory-augmented neural networks. arXiv preprint arXiv:1605.06065, 2016.
+
+Lawrence K Saul and Michael I Jordan. Exploiting tractable substructures in intractable networks. In Advances in Neural Processing Systems 8, 1996.
+
+Theano Development Team. Theano: A Python framework for fast computation of mathematical expressions. arXiv e-prints, abs/1605.02688, May 2016. URL http://arxiv.org/abs/ 1605.02688.
+
+L. Theis, A. van den Oord, and M. Bethge. A note on the evaluation of generative models. In International Conference on Learning Representations (ICLR), 2016.
+
+Oriol Vinyals, Samy Bengio, and Manjunath Kudlur. Order matters: sequence to sequence for sets. In International Conference on Learning Representations (ICLR), 2016a.
+
+Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Koray Kavukcuoglu, and Daan Wierstra. Matching networks for one shot learning. arXiv preprint arXiv:1606.04080, 2016b.
+
+Lior Wolf, Tal Hassner, and Itay Maoz. Face recognition in unconstrained videos with matched background similarity. In Computer Vision and Pattern Recognition (CVPR), 2011 IEEE Conference on, pp. 529–534. IEEE, 2011.
+
+# A APPENDIX A: PSEUDOCODE
+
+# Algorithm 1 Sampling a dataset of size $k$
+
+sample $c \sim p ( c )$   
+for $i = 1$ to $k$ do sample $z _ { i , L } \sim p ( z _ { L } | c ; \theta )$ for $j = L - 1$ to 1 do sample $z _ { i , j } \sim p ( z _ { j } | z _ { i , j + 1 } , c ; \theta )$ end for sample $x _ { i } \sim p ( x | z _ { i , 1 } , . . . , z _ { i , L } , c ; \theta )$   
+end for
+
+<table><tr><td>Algorithm 2 Sampling a dataset of size k conditioned on a dataset of size m</td></tr><tr><td>μc,O² ← q(c|x1,...,Xm; Φ) {Calculate approximate posterior over c using statistic network.} c ← μc {Set c to be the mean of the approximate posterior.}</td></tr><tr><td>fori=1 to k do sample zi,L ~ p(zLlc; 0)</td></tr><tr><td>forj=L-1to1do</td></tr><tr><td>sample zi,j ~ p(zj|zi,j+1,C;0)</td></tr><tr><td>end for</td></tr><tr><td></td></tr><tr><td>sample xi ~p(x|zi,1,.., Zi,L,c;0)</td></tr></table>
+
+# Algorithm 3 Selecting a representative sample of size $k$
+
+S ← {x1, . . . , xm}   
+I ← {1, . . . , m}   
+SI = {xi ∈ S : i ∈ I}   
+$N _ { S _ { I } }  q ( c | S _ { I } ; \phi )$ {Calculate approximate posterior over $c$ using statistic network.}   
+for $i = 1$ to $k$ do $\begin{array} { l } { t \gets a r g m i n _ { j \in I } D _ { K L } \left( N _ { S } \| N _ { S _ { I - j } } \right) } \\ { I \gets I - t } \end{array}$   
+end for
+
+<table><tr><td>Algorithm4K-way few-shot classification</td></tr><tr><td>Do,...,Dk ← sets of labelled examples for each class</td></tr><tr><td>x ← datapoint to be classified</td></tr><tr><td>Nx ← q(c|x;) {approximate posterior over c given query point}</td></tr><tr><td>for i=1 to K do</td></tr><tr><td>Ni ← q(c|Di;Φ)</td></tr><tr><td>end for</td></tr><tr><td>y ←argminiDkL (NillNx)</td></tr></table>
+
+# B APPENDIX B: FURTHER EXPERIMENTAL DETAILS
+
+# B.1 OMNIGLOT
+
+# Shared encoder $x \to h$
+
+$\overline { { 2 \times \left\{ \begin{array} { l } { c o n \nu 2 d 6 4 } \end{array} \right. } }$ feature maps with $3 \times 3$ kernels and ELU activations } conv2d 64 feature maps with $3 \times 3$ kernels, stride 2 and ELU activations $2 \times \left\{ c o n \nu 2 d 1 2 \ 8 \right.$ feature maps with $3 \times 3$ kernels and ELU activations $\}$ conv2d 128 feature maps with $3 \times 3$ kernels, stride 2 and ELU activations $2 \times \{ c o n \nu 2 d 2 5 6$ feature maps with $3 \times 3$ kernels and ELU activations $\}$ conv2d 256 feature maps with $3 \times 3$ kernels, stride 2 and ELU activations
+
+Statistic network $q ( c | D ; \phi ) : h _ { 1 } , \ldots , h _ { k } \to \mu _ { c } , \sigma _ { c } ^ { 2 }$ fully-connected layer with 256 units and ELU activations sample-dropout and concatenation with number of samples average pooling within each dataset $2 \times$ {fully-connected layer with 256 units and ELU activations $\}$ fully-connected linear layers to $\mu _ { c }$ and $\log \sigma _ { c } ^ { 2 }$
+
+# Inference network $q ( z | x , c ; \phi ) : h , c \to \mu _ { z } , \sigma _ { z } ^ { 2 }$
+
+concatenate c and $\overline { { h } }$ $3 \times$ {fully-connected layer with 256 units and ELU activations $\}$ fully-connected linear layers to $\mu _ { z }$ and $\log \sigma _ { z } ^ { 2 }$
+
+Latent decoder network $p ( z | c ; \theta ) : c  \mu _ { z } , \sigma _ { z } ^ { 2 }$ $\overline { { 3 \times } }$ {fully-connected layer with 256 units and ELU activations } fully-connected linear layers to $\mu _ { z }$ and $\log \sigma _ { z } ^ { 2 }$
+
+# Observation decoder network $p ( x | c , z ; \theta ) : c , z \to \mu _ { x }$
+
+concatenate $z$ and $c$ fully-connected linear layers with $4 \cdot 4 \cdot 2 5 6$ units $2 \times \ \left\{ \begin{array} { r l } \end{array} \right.$ { conv2d 256 feature maps with $3 \times 3$ kernels and ELU activations $\}$ deconv2d 256 feature maps with $2 \times 2$ kernels, stride 2, ELU activations $2 \times \left\{ \begin{array} { r l } \end{array} \right.$ { conv2d 128 feature maps with $3 \times 3$ kernels and ELU activations $\}$ deconv2d 128 feature maps with $2 \times 2$ kernels, stride 2, ELU activations $2 \times \left\{ \begin{array} { r l } \end{array} \right.$ { conv2d 64 feature maps with $3 \times 3$ kernels and ELU activations $\}$ deconv $2 d 6 4$ feature maps with $2 \times 2$ kernels, stride 2, ELU activations conv2d 1 feature map with $1 \times 1$ kernels, sigmoid activations
+
+# B.2 YOUTUBE FACES
+
+# Shared encoder $x \to h$
+
+$\overline { { 2 \times \{ \ c o n \nu 2 d \} 3 2 } }$ feature maps with $\overline { { 3 \times 3 } }$ kernels and ELU activations $ { \mathfrak { J } }$ conv2d 32 feature maps with $3 \times 3$ kernels, stride 2 and ELU activations $2 \times \left\{ c o n \nu 2 d \ : 6 4 \right.$ feature maps with $3 \times 3$ kernels and ELU activations $\}$ conv2d 64 feature maps with $3 \times 3$ kernels, stride 2 and ELU activations $2 \times \left\{ \begin{array} { l l } { c o n \nu 2 d 1 2 8 } \end{array} \right.$ feature maps with $3 \times 3$ kernels and ELU activations $\}$ conv2d 128 feature maps with $3 \times 3$ kernels, stride 2 and ELU activations $2 \times \{ c o n \nu 2 d 2 5 6$ feature maps with $3 \times 3$ kernels and ELU activations $\}$ conv2d 256 feature maps with $3 \times 3$ kernels, stride 2 and ELU activations
+
+Statistic network $q ( c | D , \phi ) : h _ { 1 } , \ldots , h _ { k } \to \mu _ { c } , \sigma _ { c } ^ { 2 }$ fully-connected layer with 1000 units and ELU activations average pooling within each dataset fully-connected linear layers to $\mu _ { c }$ and $\log \sigma _ { c } ^ { 2 }$
+
+Inference network $q ( z | x , c , \phi ) : h , c \to \mu _ { z } , \sigma _ { z } ^ { 2 }$ concatenate c and $\overline { { h } }$ fully-connected layer with 1000 units and ELU activations fully-connected linear layers to $\mu _ { z }$ and $\log \sigma _ { z } ^ { 2 }$
+
+Latent decoder network $p ( z | c , ; \theta ) : c  \mu _ { z } , \sigma _ { z } ^ { 2 }$ fully-connected layer with 1000 units and ELU activations fully-connected linear layers to $\mu _ { z }$ and $\log \sigma _ { z } ^ { 2 }$
+
+# Observation decoder network $p ( x | c , z ; \theta ) : c , z  \mu _ { x }$
+
+concatenate $z$ and $c$ fully-connected layer with 1000 units and ELU activations fully-connected linear layer with $8 \cdot 8 \cdot 2 5 6$ units $2 \times \left\{ \begin{array} { r l } \end{array} \right.$ { conv2d 256 feature maps with $3 \times 3$ kernels and ELU activations $\}$ deconv2d 256 feature maps with $2 \times 2$ kernels, stride 2, ELU activations $2 \times \left\{ \begin{array} { r l } \end{array} \right.$ { conv2d 128 feature maps with $3 \times 3$ kernels and ELU activations $\}$ deconv2d 128 feature maps with $2 \times 2$ kernels, stride 2, ELU activations $\gtrsim \gtrsim \left\{ c o n \nu 2 d 6 4 \right.$ feature maps with $3 \times 3$ kernels and ELU activations $\}$ deconv $2 d 6 4$ feature maps with $2 \times 2$ kernels, stride 2, ELU activations $2 \times \left\{ \begin{array} { r l } \end{array} \right.$ { conv2d 32 feature maps with $3 \times 3$ kernels and ELU activations $\}$ deconv $2 d 3 2$ feature maps with $2 \times 2$ kernels, stride 2, ELU activations conv2d 3 feature maps with $1 \times 1$ kernels, sigmoid activations

parse/train/HJDBUF5le/HJDBUF5le_content_list.json

@@ -0,0 +1,1641 @@
+[
+    {
+        "type": "text",
+        "text": "TOWARDS A NEURAL STATISTICIAN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            606,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Amos Storkey ",
+        "text_level": 1,
+        "bbox": [
+            537,
+            146,
+            635,
+            159
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Harrison Edwards   \nSchool of Informatics   \nUniversity of Edinburgh   \nEdinburgh, UK   \nH.L.Edwards@sms.ed.ac.uk ",
+        "bbox": [
+            183,
+            145,
+            419,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "School of Informatics University of Edinburgh Edinburgh, UK A.Storkey@ed.ac.uk ",
+        "bbox": [
+            537,
+            160,
+            714,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            248,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "An efficient learner is one who reuses what they already know to tackle a new problem. For a machine learner, this means understanding the similarities amongst datasets. In order to do this, one must take seriously the idea of working with datasets, rather than datapoints, as the key objects to model. Towards this goal, we demonstrate an extension of a variational autoencoder that can learn a method for computing representations, or statistics, of datasets in an unsupervised fashion. The network is trained to produce statistics that encapsulate a generative model for each dataset. Hence the network enables efficient learning from new datasets for both unsupervised and supervised tasks. We show that we are able to learn statistics that can be used for: clustering datasets, transferring generative models to new datasets, selecting representative samples of datasets and classifying previously unseen classes. We refer to our model as a neural statistician, and by this we mean a neural network that can learn to compute summary statistics of datasets without supervision. ",
+        "bbox": [
+            233,
+            280,
+            764,
+            464
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            491,
+            336,
+            507
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The machine learning community is well-practised at learning representations of data-points and sequences. A middle-ground between these two is representing, or summarizing, datasets - unordered collections of vectors, such as photos of a particular person, recordings of a given speaker or a document as a bag-of-words. Where these sets take the form of i.i.d samples from some distribution, such summaries are called statistics. We explore the idea of using neural networks to learn statistics and we refer to our approach as a neural statistician. ",
+        "bbox": [
+            174,
+            522,
+            825,
+            602
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The key result of our approach is a statistic network that takes as input a set of vectors and outputs a vector of summary statistics specifying a generative model of that set - a mean and variance specifying a Gaussian distribution in a latent space we term the context. The advantages of our approach are that it is: ",
+        "bbox": [
+            176,
+            608,
+            825,
+            662
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• Unsupervised: It provides principled and unsupervised way to learn summary statistics as the output of a variational encoder of a generative model.   \n• Data efficient: If one has a large number of small but related datasets, modelling the datasets jointly enables us to gain statistical strength.   \n• Parameter Efficient: By using summary statistics instead of say categorical labellings of each dataset, we decouple the number of parameters of the model from the number of datasets.   \n• Capable of few-shot learning: If the datasets correspond to examples from different classes, class embeddings (summary statistics associated with examples from a class), allow us to handle new classes at test time. ",
+        "bbox": [
+            215,
+            674,
+            825,
+            824
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 PROBLEM STATEMENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            843,
+            393,
+            859
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We are given datasets $D _ { i }$ for $i \\in \\mathcal { Z }$ . Each dataset $D _ { i } = \\{ x _ { 1 } , \\ldots , x _ { k _ { i } } \\}$ consists of a number of i.i.d samples from an associated distribution $p _ { i }$ over $\\mathbb { R } ^ { n }$ . The task can be split into learning and inference components. The learning component is to produce a generative model $\\hat { p } _ { i }$ for each dataset $D _ { i }$ . We assume there is a common underlying generative process $p$ such that $p _ { i } = p ( \\cdot | c _ { i } )$ for $c _ { i } \\in \\mathbb { R } ^ { l }$ drawn from $p ( c )$ . We refer to $c$ as the context. The inference component is to give an approximate posterior over the context $q ( c | D )$ for a given dataset produced by a statistic network. ",
+        "bbox": [
+            174,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 NEURAL STATISTICIAN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            145,
+            400,
+            160
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In order to exploit the assumption of a hierarchical generative process over datasets we will use a ‘parameter-transfer approach’ (see Pan & Yang, 2010) to extend the variational autoencoder model of Kingma & Welling (2013). ",
+        "bbox": [
+            173,
+            175,
+            826,
+            217
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/6e6de22e59acbd630cacaf80d1e1542ac5d29c3f4627ec81e0775900d79c83d2.jpg",
+        "image_caption": [
+            "Figure 1: Left: basic hierarchical model, where the plate encodes the fact that the context variable $c$ is shared across each item in a given dataset. Center: full neural statistician model with three latent layers $z _ { 1 } , z _ { 2 } , z _ { 3 }$ . Each collection of incoming edges to a node is implemented as a neural network, the input of which is the concatenation of the edges’ sources, the output of which is a parameterization of a distribution over the random variable represented by that node. Right: The statistic network, which combines the data via an exchangeable statistic layer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            229,
+            748,
+            354
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 VARIATIONAL AUTOENCODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            465,
+            423,
+            479
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The variational autoencoder is a latent variable model $p ( x | z ; \\theta )$ (often called the decoder) with parameters $\\theta$ . For each observed $x$ , a corresponding latent variable $z$ is drawn from $p ( z )$ so that ",
+        "bbox": [
+            173,
+            489,
+            823,
+            518
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3b4d3bf715b866c4902cc23a60b5d7b91b8b3d7badae24b8b7baf2acedf1274d.jpg",
+        "text": "$$\np ( x ) = \\int p ( x | z ; \\theta ) p ( z ) d z .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            525,
+            591,
+            558
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The generative parameters $\\theta$ are learned by introducing a recognition network (also called an encoder) $q ( z | x ; \\phi )$ with parameters $\\phi$ . The recognition network gives an approximate posterior over the latent variables that can then be used to give the standard variational lower bound (Saul & Jordan, 1996) on the single-datum log-likelihood. I.e. $\\log P ( x | \\theta ) \\geq \\mathcal { L } _ { x }$ , where ",
+        "bbox": [
+            173,
+            564,
+            825,
+            618
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/126615051814df59d457186f5e52e4b15ea7cc97b1c04d73d37be229a9d23e42.jpg",
+        "text": "$$\n\\mathcal { L } _ { x } = \\mathbb { E } _ { q ( z | x , \\phi ) } \\left[ \\log p ( x | z ; \\theta ) \\right] - D _ { K L } \\left( q ( z | x ; \\phi ) \\| p ( z ) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            625,
+            684,
+            643
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Likewise the full-data log likelihood is lower bounded by the sum of the ${ \\mathcal { L } } _ { x }$ terms over the whole dataset. We can then optimize this lower bound with respect to $\\phi$ and $\\theta$ using the reparameterization trick introduced by Kingma & Welling (2013) and Rezende et al. (2014) to get a Monte-Carlo estimate of the gradient. ",
+        "bbox": [
+            173,
+            647,
+            825,
+            703
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.2 BASIC MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            718,
+            315,
+            733
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We extend the variational autoencoder to the model depicted on the left in Figure 1. This includes a latent variable $c$ , the context, that varies between different datasets but is constant, a priori, for items within the same dataset. Now, the likelihood of the parameters $\\theta$ for one single particular dataset $D$ is given by ",
+        "bbox": [
+            173,
+            744,
+            825,
+            797
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bb6d4b66451063ecc778fce4931a79b5f1e5903a578d64568e6388bfa2646ae1.jpg",
+        "text": "$$\np ( D ) = \\int p ( c ) \\left[ \\prod _ { x \\in D } \\int p ( x | z ; \\theta ) p ( z | c ; \\theta ) d z \\right] d c .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            796,
+            666,
+            839
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The prior $p ( c )$ is chosen to be a spherical Gaussian with zero mean and unit variance. The conditional $p ( z | c ; \\theta )$ is Gaussian with diagonal covariance, where all the mean and variance parameters depend on $c$ through a neural network. Similarly the observation model $p ( x | z ; \\theta )$ will be a simple likelihood function appropriate to the data modality with dependence on $z$ parameterized by a neural network. For example, with real valued data, a diagonal Gaussian likelihood could be used where the mean and log variance of $x$ are created from $z$ via a neural network. ",
+        "bbox": [
+            173,
+            843,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We use approximate inference networks $q ( \\boldsymbol { z } | \\boldsymbol { x } , c ; \\phi )$ , $q ( c | D ; \\phi )$ , with parameters collected into $\\phi$ , to once again enable the calculation and optimization of a variational lower bound on the loglikelihood. The single dataset log likelihood lower bound is given by ",
+        "bbox": [
+            173,
+            103,
+            825,
+            145
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f982395bbcaa9741da04ded25f517d539a1872dba8f7ae1eeedfa345d0bac6a6.jpg",
+        "text": "$$\n\\begin{array}{c} \\mathcal { L } _ { D } = \\mathbb { E } _ { q ( c | D ; \\phi ) } \\left[ \\sum _ { x \\in d } \\mathbb { E } _ { q ( z | c , x ; \\phi ) } \\left[ \\log p ( x | z ; \\theta ) \\right] - D _ { K L } \\left( q ( z | c , x ; \\phi ) \\| p ( z | c ; \\theta ) \\right) \\right]  \\\\ & { \\phantom { = \\ } - D _ { K L } \\left( q ( c | D ; \\phi ) \\| p ( c ) \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            152,
+            790,
+            218
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As with the generative distributions, the likelihood forms for $q ( \\boldsymbol { z } | \\boldsymbol { x } , c ; \\phi )$ and $q ( c | D ; \\phi )$ are diagonal Gaussian distributions, where all the mean and log variance parameters in each distribution are produced by a neural network taking the conditioning variables as inputs. Note that $q ( c | D ; \\phi )$ accepts as input a dataset $D$ and we refer to this as the statistic network. We describe this in Subsection 3.4. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            276
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The full-data variational bound is given by summing the variational bound for each dataset in our collection of datasets. It is by learning the difference of the within-dataset and between-dataset distributions that we are able to discover an appropriate statistic network. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            323
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3 FULL MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            338,
+            308,
+            352
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The basic model works well for modelling simple datasets, but struggles when the datasets have complex internal structure. To increase the sophistication of the model we use multiple stochastic layers $z _ { 1 } , \\ldots , z _ { k }$ and introduce skip-connections for both the inference and generative networks. The generative model is shown graphically in Figure 1 in the center. The probability of a dataset $D$ is then given by ",
+        "bbox": [
+            174,
+            363,
+            825,
+            431
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2c1360f591adc84214572f752907f5d3163d3dfa42aec7b3849830c5f27b0558.jpg",
+        "text": "$$\np ( D ) = \\int p ( c ) \\prod _ { x \\in D } \\int p ( x | c , z _ { 1 : L } ; \\theta ) p ( z _ { L } | c ; \\theta ) \\prod _ { i = 1 } ^ { L - 1 } p ( z _ { i } | z _ { i + 1 } , c ; \\theta ) d z _ { 1 : L } d c\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            446,
+            750,
+            491
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the $p ( z _ { i } | z _ { i + 1 } , c , \\theta )$ are again Gaussian distributions where the mean and log variance are given as the output of neural networks. The generative process for the full model is described in Algorithm 1. ",
+        "bbox": [
+            174,
+            493,
+            826,
+            535
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The full approximate posterior factorizes analogously as ",
+        "bbox": [
+            174,
+            540,
+            545,
+            555
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a1d62b31fdc26b6326df3dc437fc5803caea2f8f3eb63323252fc977cb71a8d9.jpg",
+        "text": "$$\nq ( c , z _ { 1 : L } | D ; \\phi ) = q ( c | D ; \\phi ) \\prod _ { x \\in D } q ( z _ { L } | x , c ; \\phi ) \\prod _ { i = 1 } ^ { L - 1 } q ( z _ { i } | z _ { i + 1 } , x , c ; \\phi ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            570,
+            725,
+            614
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For convenience we give the variational lower bound as sum of a three parts, a reconstruction term $R _ { D }$ , a context divergence $C _ { D }$ and a latent divergence $L _ { D }$ : ",
+        "bbox": [
+            176,
+            625,
+            825,
+            652
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/46680fb0c4f8fefaf7ea13df377ea84b150778e3ce2b656aff69fd13b5651c81.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle R _ { D } = \\mathbb { E } _ { q ( c | D ; \\phi ) } \\sum _ { x \\in D } \\mathbb { E } _ { q ( z _ { 1 : L } | c , x ; \\phi ) } \\log p ( x | z _ { 1 : L } , c ; \\theta ) } \\\\ { \\displaystyle C _ { D } = D _ { K L } \\left( q ( c | D ; \\phi ) \\| p ( c ) \\right) } \\\\ { \\displaystyle L _ { D } = \\mathbb { E } _ { q ( c , z _ { 1 : L } | D ; \\phi ) } \\left[ \\displaystyle \\sum _ { x \\in D } D _ { K L } \\left( q ( z _ { L } | c , x ; \\phi ) \\| p ( z _ { L } | c ; \\theta ) \\right) \\right. } \\\\ { \\displaystyle \\left. \\qquad \\quad + \\displaystyle \\sum _ { i = 1 } ^ { L - 1 } D _ { K L } \\left( q ( z _ { i } | z _ { i + 1 } , c , x ; \\phi ) \\| p ( z _ { i } | z _ { i + 1 } , c ; \\theta ) \\right) \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            209,
+            674,
+            761,
+            819
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The skip-connections $p ( z _ { i } | z _ { i + 1 } , c ; \\theta )$ and $q ( z _ { i } | z _ { i + 1 } , x ; \\phi )$ allow the context to specify a more precise distribution for each latent variable by explaining-away more generic aspects of the dataset at each stochastic layer. This architecture was inspired by recent work on probabilistic ladder networks in Kaae Sønderby et al. (2016). Complementing these are the skip-connections from each latent variable to the observation $p ( x | z _ { 1 : L } , c ; \\theta )$ , the intuition here is that each stochastic layer can focus on representing a certain level of abstraction, since its information does not need to be copied into the next layer, a similar approach was used in Maaløe et al. (2016). ",
+        "bbox": [
+            173,
+            829,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Once again, note that we are maximizing the lower bound to the log likelihood over many datasets $D$ : we want to maximize the expectation of $\\mathcal { L } _ { D }$ over all datasets. We do this optimization using stochastic gradient descent. In contrast to a variational autoencoder where a minibatch would consist of a subsample of datapoints from the dataset, we use minibatches consisting of a subsample of datasets - tensors of shape (batch size, sample size, number of features). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            171
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 STATISTIC NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            186,
+            362,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In addition to the standard inference networks we require a statistic network $q ( c | D ; \\phi )$ to give an approximate posterior over the context $c$ given a dataset $D = \\{ x _ { 1 } , \\ldots , x _ { k } \\}$ . This inference network must capture the exchangeability of the data in $D$ . ",
+        "bbox": [
+            176,
+            212,
+            825,
+            253
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use a feedforward neural network consisting of three main elements: ",
+        "bbox": [
+            176,
+            260,
+            647,
+            273
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• An instance encoder $E$ that takes each individual datapoint $x _ { i }$ to a vector $e _ { i } = E ( x _ { i } )$ . • An exchangeable instance pooling layer that collapses the matrix $( e _ { 1 } , \\ldots , e _ { k } )$ to a single pre-statistic vector $v$ . Examples include elementwise means, sums, products, geometric means and maximum. We use the sample mean for all experiments. • A final post-pooling network that takes $v$ to a parameterization of a diagonal Gaussian. ",
+        "bbox": [
+            207,
+            285,
+            825,
+            363
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The graphical model for this is given at the right of Figure 1. ",
+        "bbox": [
+            174,
+            373,
+            570,
+            388
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We note that the humble sample mean already gives the statistic network a great deal of representational power due to the fact that the instance encoder can learn a representation where averaging makes sense. For example since the instance encoder can approximate a polynomial on a compact domain, and so can the post-pooling network, a statistic network can approximate any moment of a distribution. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            460
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            468,
+            344,
+            484
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Due to the general nature of the problem considered, our work touches on many different topics which we now attempt to summarize. ",
+        "bbox": [
+            176,
+            500,
+            823,
+            526
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Topic models and graphical models The form of the graphical model in Figure 1 on the left is equivalent to that of a standard topic model. In contrast to traditional topic models we do not use discrete latent variables, or restrict to discrete data. Work such as that by Ranganath et al. (2014) has extended topic models in various directions, but importantly we use flexible conditional distributions and dependency structures parameterized by deep neural networks. Recent work has explored neural networks for document models (see e.g. Miao et al., 2015) but has been limited to modelling datapoints with little internal structure. Along related lines are ‘structured variational autoencoders’ (see Johnson et al., 2016), where they treat the general problem of integrating graphical models with variational autoencoders. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            655
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Transfer learning There is a considerable literature on transfer learning, for a survey see Pan & Yang (2010). There they discuss ‘parameter-transfer’ approaches whereby parameters or priors are shared across datasets, and our work fits into that paradigm. For examples see Lawrence & Platt (2004) where share they priors between Gaussian processes, and Evgeniou & Pontil (2004) where they take an SVM-like approach to share kernels. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            736
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One-shot Learning Learning quickly from small amounts of data is a topic of great interest. Lake et al. (2015) use Bayesian program induction for one-shot generation and classification, and Koch (2015) train a Siamese (Chopra et al. (2005)) convolutional network for one-shot image classification. We note the relation to the recent work (Rezende et al., 2016) in which the authors use a conditional recurrent variational autoencoder capable of one-shot generalization by taking as extra input a conditioning data point. The important differences here are that we jointly model datasets and datapoints and consider datasets of any size. Recent approaches to one-shot classification are matching networks (Vinyals et al., 2016b) (which was concurrent with the initial preprint of this work), and related previous work (Santoro et al., 2016). The former can be considered a kind of differentiable nearest neighbour classifier, and the latter augments their network with memory to store information about the classification problem. Both are trained end-to-end for the classification problem, whereas the present work is a general approach to learning representations of datasets. Probably the closest previous work is by Salakhutdinov et al. (2012) where the authors learn a topic model over the activations of a DBM for one-shot learning. Compared with their work we use modern architectures and easier to train VAEs, in particular we have fast and amortized feedforward inference for test (and training) datasets, avoiding the need for MCMC. ",
+        "bbox": [
+            174,
+            751,
+            825,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            143
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Multiple-Instance Learning There is previous work on classifying sets in multiple-instance learning, for a useful survey see Cheplygina et al. (2015). Typical approaches involve adapting kernel based methods such as support measure machines (Muandet et al., 2012), support distribution machines (Poczos et al., 2012) and ´ multiple-instance-kernels (Gartner et al., 2002). We do not consider applications to multiple-instance learning type problems here, but it may be fruitful to do so in the future. ",
+        "bbox": [
+            174,
+            160,
+            823,
+            241
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Set2Seq In very related work, Vinyals et al. (2016a) explore architectures for mapping sets to sequences. There they use an LSTM to repeatedly compute weighted-averages of the datapoints and use this to tackle problems such as sorting a list of numbers. The main difference between their work and ours is that they primarily consider supervised problems, whereas we present a general unsupervised method for learning representations of sets of i.i.d instances. In future work we may also explore recurrently computing statistics. ",
+        "bbox": [
+            174,
+            257,
+            823,
+            337
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "ABC There has also been work on learning summary statistics for Approximate Bayesian Computation by either learning to predict the parameters generating a sample as a supervised problem, or by using kernel embeddings as infinite dimensional summary statistics. See the work by Fukumizu et al. (2013) for an example of kernel-based approaches. More recently Jiang et al. (2015) used deep neural networks to predict the parameters generating the data. The crucial differences are that their problem is supervised, they do not leverage any exchangeability properties the data may have, nor can it deal with varying sample sizes. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            446
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            462,
+            418,
+            477
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given an input set $x _ { 1 } , \\ldots x _ { k }$ we can use the statistic network to calculate an approximate posterior over contexts $q ( c | x _ { 1 } , \\ldots , x _ { k } ; \\phi )$ . Under the generative model, each context $c$ specifies a conditional model $p ( x | c ; \\bar { \\theta } )$ . To get samples from the model corresponding to the most likely posterior value of $c$ , we set $c$ to the mean of the approximate posterior and then sample directly from the conditional distributions. This is described in Algorithm 2. We use this process in our experiments to show samples. In all experiments, we use the Adam optimization algorithm (Kingma & Ba, 2014) to optimize the parameters of the generative models and variational approximations. Batch normalization (Ioffe & Szegedy, 2015) is implemented for convolutional layers and we always use a batch size of 16. We primarily use the Theano (Theano Development Team, 2016) framework with the Lasagne (Dieleman et al., 2015) library, but the final experiments with face data were done using Tensorflow (Abadi et al., 2015). In all cases experiments were terminated after a given number of epochs when training appeared to have sufficiently converged (300 epochs for omniglot, youtube and spatial MNIST examples, and 50 epochs for the synthetic experiment). ",
+        "bbox": [
+            173,
+            494,
+            825,
+            666
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 SIMPLE 1-D DISTRIBUTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            684,
+            415,
+            698
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our first experiment we wanted to know if the neural statistician will learn to cluster synthetic 1-D datasets by distribution family. We generated a collection of synthetic 1-D datasets each containing 200 samples. Datasets consist of samples from either an Exponential, Gaussian, Uniform or Laplacian distribution with equal probability. Means and variances are sampled from $U [ - 1 , 1 ]$ and $U [ \\bar { 0 } . 5 , 2 ]$ respectively. The training data contains $1 0 K$ sets. ",
+        "bbox": [
+            174,
+            710,
+            823,
+            776
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The architecture for this experiment contains a single stochastic layer with 32 units for $z$ and 3 units for $c _ { \\cdot }$ , . The model $p ( \\boldsymbol { x } | \\boldsymbol { z } , c ; \\boldsymbol { \\theta } )$ and variational approximation $\\dot { q ( \\boldsymbol { z } | \\boldsymbol { x } , \\boldsymbol { c } ; \\boldsymbol { \\phi } ) }$ are each a diagonal Gaussian distribution with all mean and log variance parameters given by a network composed of three dense layers with ReLU activations and 128 units. The statistic network determining the mean and log variance parameters of posterior over context variables is composed of three dense layers before and after pooling, each with 128 units with Rectified Linear Unit (ReLU) activations. ",
+        "bbox": [
+            174,
+            784,
+            823,
+            863
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 shows 3-D scatter plots of the summary statistics learned. Notice that the different families of distribution cluster. It is interesting to observe that the Exponential cluster is differently orientated to the others, perhaps reflecting the fact that it is the only non-symmetric distribution. We also see that between the Gaussian and Laplacian clusters there is an area of ambiguity which is as one might expect. We also see that within each cluster the mean and variance are mapped to orthogonal directions. ",
+        "bbox": [
+            174,
+            869,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/e82aa8476b90fc3fe6c80a77c4987d5d4f95485cd667e79fb1c7bdb8913f02e9.jpg",
+        "image_caption": [
+            "Figure 2: Three different views of the same data. Each point is the mean of the approximate posterior over the context $q ( c | D ; \\phi )$ where $c \\in \\mathbb { R } ^ { 3 }$ . Each point is a summary statistic for a single dataset with 200 samples. Top plot shows points colored by distribution family, left plot colored by the mean and right plot colored by the variance. The plots have been rotated to illustrative angles. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            99,
+            756,
+            352
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            440,
+            821,
+            468
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 SPATIAL MNIST ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            484,
+            331,
+            498
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Building on the previous experiments we investigate 2-D datasets that have complex structure, but the datapoints contain little information by themselves, making it a good test of the statistic network. We created a dataset called spatial MNIST. In spatial MNIST each image from MNIST (LeCun et al., 1998) is turned into a dataset by interpreting the normalized pixel intensities as a probability density and sampling coordinate values. An example is shown in Figure 3. This creates two-dimensional spatial datasets. We used a sample size of 50. Note that since the pixel coordinates are discrete, it is necessary to dequantize them by adding uniform noise $u \\sim U [ 0 , 1 ]$ to the coordinates if one models them as real numbers, else you can get arbitrarily high densities (see Theis et al. (2016) for a discussion of this point). ",
+        "bbox": [
+            174,
+            510,
+            599,
+            681
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/5260004343dab07772be2c07e4ccd346a980af8a90502f574063c61798f31e23.jpg",
+        "image_caption": [
+            "Figure 3: An image from MNIST on the left, transformed to a set of 50 $( x , y )$ coordinates, shown as a scatter plot on the right. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            651,
+            512,
+            781,
+            580
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The generative architecture for this experiment contains 3 stochastic $z$ layers, each with 2 units, and a single $c$ layer with 64 units. The means and log variances of the Gaussian likelihood for $p ( x | z _ { 1 : 3 } , \\bar { c } ; \\theta )$ , and each subnetwork for $z$ in both the encoder and decoder contained 3 dense layers with 256 ReLU units each. The statistic network also contained 3 dense layers pre-pooling and 3 dense layers post pooling with 256 ReLU units. ",
+        "bbox": [
+            174,
+            689,
+            823,
+            755
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In addition to being able to sample from the model conditioned on a set of inputs, we can also summarize a dataset by choosing a subset $S \\subseteq D$ to minimise the KL divergence of $q ( C | D ; \\phi )$ from $q ( C | S ; \\phi )$ . We do this greedily by iteratively discarding points from the full sample. Pseudocode for this process is given in Algorithm 3. The results are shown in Figure 4. We see that the model is capable of handling complex arrangements of datapoints. We also see that it can select sensible subsets of a dataset as a summary. ",
+        "bbox": [
+            174,
+            761,
+            825,
+            842
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.3 OMNIGLOT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            858,
+            292,
+            872
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Next we work with the OMNIGLOT data (Lake et al., 2015). This contains 1628 classes of handwritten characters but with just 20 examples per class. This makes it an excellent test-bed for transfer / few-shot learning. We constructed datasets by splitting each class into datasets of size 5. We train on datasets drawn from 1200 classes and reserve the remaining classes to test few-shot sampling and classification. We created new classes by rotating and reflecting characters. We resized the images to $2 8 \\times 2 8$ . We sampled a binarization of each image for each epoch. We also randomly applied the dilation operator from computer vision as further data augmentation since we observed that the stroke widths are quite uniform in the OMNIGLOT data, whereas there is substantial variation in MNIST, this augmentation improved the visual quality of the few-shot MNIST samples considerably and increased the few-shot classification accuracy by about 3 percent. Finally we used ‘sample dropout’ whereby a random subset of each dataset was removed from the pooling in the statistic network, and then included the number of samples remaining as an extra feature. This was beneficial since it reduced overfitting and also allowed the statistic network to learn to adjust the approximate posterior over $c$ based on the number of samples. ",
+        "bbox": [
+            176,
+            883,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/28105ff1bd0578e7f26caba92274867ed296cc4f906f44fda9289ea57607f180.jpg",
+        "image_caption": [
+            "Figure 4: Conditioned samples from spatial MNIST data. Blue and red digits are the input sets, black digits above correspond to samples given the input. Red points correspond to a 6-sample summary of the dataset "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            102,
+            823,
+            180
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c4d7da7a84dd63fbee15ce45457934785ddee8a48d232a86fb352d939fe0c78a.jpg",
+        "image_caption": [
+            "Figure 5: Few-shot learning Left: Few-shot learning from OMNIGLOT to MNIST. Left rows are input sets, right rows are samples given the inputs. Right: Few-shot learning from with OMNIGLOT data to unseen classes. Left rows are input sets, right rows are samples given the inputs. Black-white inversion is applied for ease of viewing. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            246,
+            795,
+            446
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            531,
+            825,
+            678
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We used a single stochastic layer with 16 units for $z$ , and 512 units for $c$ . We used a shared convolutional encoder between the inference and statistic networks and a deconvolutional decoder network. Full details of the networks are given in Appendix B.1. The decoder used a Bernoulli likelihood. ",
+        "bbox": [
+            176,
+            684,
+            825,
+            724
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Figure 5 we show two examples of few-shot learning by conditioning on samples of unseen characters from OMNIGLOT, and conditioning on samples of digits from MNIST. The samples are mostly of a high-quality, and this shows that the neural statistician can generalize even to new datasets. ",
+        "bbox": [
+            174,
+            731,
+            823,
+            785
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As a further test we considered few-shot classification of both unseen OMNIGLOT characters and MNIST digits. Given a sets of labelled examples of each class $D _ { 0 } , \\ldots , D _ { 9 }$ (for MNIST say), we computed the approximate posteriors $q ( C | D _ { i } ; \\phi )$ using the statistic network. Then for each test image $x$ we also computed the posterior $q ( C | x ; \\phi )$ and classified it according to the training dataset $D _ { i }$ minimizing the KL divergence from the test context $t o$ the training context. This process is described in Algorithm 4. We tried this with either 1 or 5 labelled examples per class and either 5 or 20 classes. For each trial we randomly select $K$ classes, randomly select training examples for each class, and test on the remaining examples. This process is repeated 100 times and the results averaged. The results are shown in Table 1. We compare to a number of results reported in Vinyals et al. (2016b) including Santoro et al. (2016) and Koch (2015). Overall we see that the neural statistician model can be used as a strong classifier, particularly for the 5-way tasks, but performs worse than matching networks for the 20-way tasks. One important advantage that matching networks have is that, whilst each class is processed independently in our model, the representation in matching networks is conditioned on all of the classes in the few-shot problem. This means that it can exaggerate differences between similar classes, which are more likely to appear in a 20-way problem than a 5-way problem. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            184
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/186491048f128aad4887f4573db79cc2f76a92a4d7d0ffd7fb9afe1b41651b8c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">Task</td><td rowspan=\"2\"></td><td colspan=\"3\">Method</td></tr><tr><td>Test Dataset</td><td>K Shot</td><td>K Way</td><td>Siamese</td><td>MANN</td><td>Matching Ours</td></tr><tr><td>MNIST</td><td>1</td><td>10</td><td>70</td><td>=</td><td>72</td><td>78.6</td></tr><tr><td>MNIST</td><td>5</td><td>10</td><td>=</td><td>=</td><td>=</td><td>93.2</td></tr><tr><td>OMNIGLOT</td><td>1</td><td>5</td><td>97.3</td><td>82.8</td><td>98.1</td><td>98.1</td></tr><tr><td>OMNIGLOT</td><td>5</td><td>5</td><td>98.4</td><td>94.9</td><td>98.9</td><td>99.5</td></tr><tr><td>OMNIGLOT</td><td>1</td><td>20</td><td>88.1</td><td>-</td><td>93.8</td><td>93.2</td></tr><tr><td>OMNIGLOT</td><td>5</td><td>20</td><td>97.0</td><td>=</td><td>98.7</td><td>98.1</td></tr></table>",
+        "bbox": [
+            230,
+            188,
+            763,
+            296
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 1: The table shows the classification accuracies of various few-shot learning tasks. Models are trained on OMNIGLOT data and tested on either unseen OMNIGLOT classes or MNIST with varying numbers of samples per class (K-shot) with varying numbers of classes (K-way). Comparisons are to Vinyals et al. (2016b) (Matching), Santoro et al. (2016) (MANN) and Koch (2015) (Siamese). 5-shot MNIST results are included for completeness. ",
+        "bbox": [
+            173,
+            306,
+            825,
+            375
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 YOUTUBE FACES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            412,
+            333,
+            426
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/fafb5e74c2af1ea1f3189d1b879c5489693d5f0f55cb2ce7cdf8398d5995f5eb.jpg",
+        "image_caption": [
+            "Figure 6: Few-shot learning for face data. Samples are from model trained on Youtube Faces Database. Left: Each row shows an input set of size 5. Center: Each row shows 5 samples from the model corresponding to the input set on the left. Right: Imagined new faces generated by sampling contexts from the prior. Each row consists of 5 samples from the model given a particular sampled context. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            449,
+            794,
+            747
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, we provide a proof of concept for generating faces of a particular person. We use the Youtube Faces Database from Wolf et al. (2011). It contains 3, 245 videos of 1, 595 different people. We use the aligned and cropped to face version, resized to $6 4 \\times 6 4$ . The validation and test sets contain 100 unique people each, and there is no overlap of persons between data splits. The sets were created by sampling frames randomly without replacement from each video, we use a set size of 5 frames. We resample the sets for the training data each epoch. ",
+        "bbox": [
+            173,
+            843,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our architecture for this problem is based on one presented in Lamb et al. (2016). We used a single stochastic layer with 500 dimensional latent $c$ and 16 dimensional $z$ variable. The statistic network and the inference network $q ( \\boldsymbol { z } | \\boldsymbol { x } , c ; \\phi )$ share a common convolutional encoder, and the deocder uses deconvolutional layers. For full details see Appendix B.2. The likelihood function is a Gaussian, but where the variance parameters are shared across all datapoints, this was found to make training faster and more stable. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            184
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The results are shown in Figure 6. Whilst there is room for improvement, we see that it is possible to specify a complex distribution on-the-fly with a set of photos of a previously unseen person. The samples conditioned on an input set have a reasonable likeness of the input faces. We also show the ability of the model to generate new datasets and see that the samples have a consistent identity and varied poses. ",
+        "bbox": [
+            174,
+            190,
+            825,
+            257
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            265,
+            318,
+            280
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have demonstrated a highly flexible model on a variety of tasks. Going forward our approach will naturally benefit from advances in generative models as we can simply upgrade our base generative model, and so future work will pursue this. Compared with some other approaches in the literature for few-shot learning, our requirement for supervision is weaker: we only ask at training time that we are given datasets, but we do not need labels for the datasets, nor even information on whether two datasets represent the same or different classes. It would be interesting then to explore application areas where only this weaker form of supervision is available. There are two important limitations to this work, firstly that the method is dataset hungry: it will likely not learn useful representations of datasets given only a small number of them. Secondly at test time the few-shot fit of the generative model will not be greatly improved by using larger datasets unless the model was also trained on similarly large datasets. The latter limitation seems like a promising future research direction - bridging the gap between fast adaptation and slow training. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            454
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            469,
+            326,
+            482
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This work was supported in part by the EPSRC Centre for Doctoral Training in Data Science, funded by the UK Engineering and Physical Sciences Research Council (grant EP/L016427/1) and the University of Edinburgh. ",
+        "bbox": [
+            174,
+            492,
+            823,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            554,
+            285,
+            568
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, and Zhifeng Chen et al. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow. org/. Software available from tensorflow.org.   \nVeronika Cheplygina, David M.J. Tax, and Marco Loog. On classification with bags, groups and sets. Pattern Recognition Letters, 59:11 – 17, 2015.   \nS. Chopra, R. Hadsell, and Y. LeCun. Learning a similarity metric discriminatively, with application to face verification. In Computer Vision and Pattern Recognition, 2005. CVPR 2005. IEEE Computer Society Conference on, pp. 539–546 Vol. 1, June 2005.   \nSander Dieleman, Jan Schluter, Colin Raffel, Eben Olson, SK Sønderby, D Nouri, D Maturana, ¨ M Thoma, E Battenberg, J Kelly, et al. Lasagne: First release. Zenodo: Geneva, Switzerland, 2015.   \nTheodoros Evgeniou and Massimiliano Pontil. Regularized multi–task learning. In Proceedings of the tenth ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 109–117. ACM, 2004.   \nKenji Fukumizu, Le Song, and Arthur Gretton. Kernel Bayes’ rule: Bayesian inference with positive definite kernels. The Journal of Machine Learning Research, 14(1):3753–3783, 2013.   \nThomas Gartner, Peter A. Flach, Adam Kowalczyk, and Alex J. Smola. Multi-instance kernels. In In Proc. 19th International Conf. on Machine Learning, pp. 179–186. Morgan Kaufmann, 2002.   \nSergey 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, pp. 448–456, 2015. ",
+        "bbox": [
+            171,
+            575,
+            826,
+            925
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bai Jiang, Tung-yu Wu, Charles Zheng, and Wing H Wong. Learning summary statistic for approximate Bayesian computation via deep neural network. arXiv preprint arXiv:1510.02175, 2015. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew J Johnson, David Duvenaud, Alexander B Wiltschko, Sandeep R Datta, and Ryan P Adams. Structured vaes: Composing probabilistic graphical models and variational autoencoders. arXiv preprint arXiv:1603.06277, 2016. ",
+        "bbox": [
+            174,
+            140,
+            821,
+            181
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Casper Kaae Sønderby, Tapani Raiko, Lars Maaløe, Søren Kaae Sønderby, and Ole Winther. How to train deep variational autoencoders and probabilistic ladder networks. arXiv preprint arXiv:1602.02282, 2016. ",
+        "bbox": [
+            173,
+            190,
+            823,
+            231
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            239,
+            823,
+            268
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational Bayes. In Proceedings of the 2nd International Conference on Learning Representations (ICLR), number 2014, 2013. ",
+        "bbox": [
+            171,
+            276,
+            825,
+            306
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gregory Koch. Siamese neural networks for one-shot image recognition. Doctoral dissertation, University of Toronto, 2015. ",
+        "bbox": [
+            173,
+            314,
+            823,
+            342
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Brenden M Lake, Ruslan Salakhutdinov, and Joshua B Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015. ",
+        "bbox": [
+            173,
+            351,
+            823,
+            378
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Lamb, Vincent Dumoulin, and Aaron Courville. Discriminative regularization for generative models. arXiv preprint arXiv:1602.03220, 2016. ",
+        "bbox": [
+            173,
+            387,
+            823,
+            416
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Neil D Lawrence and John C Platt. Learning to learn with the informative vector machine. In Proceedings of the twenty-first international conference on Machine learning, pp. 65. ACM, 2004. ",
+        "bbox": [
+            173,
+            424,
+            821,
+            465
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            174,
+            474,
+            821,
+            503
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lars Maaløe, Casper Kaae Sønderby, Søren Kaae Sønderby, and Ole Winther. Auxiliary deep generative models. arXiv preprint arXiv:1602.05473, 2016. ",
+        "bbox": [
+            173,
+            511,
+            821,
+            540
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yishu Miao, Lei Yu, and Phil Blunsom. Neural variational inference for text processing. arXiv preprint arXiv:1511.06038, 2015. ",
+        "bbox": [
+            173,
+            547,
+            823,
+            577
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Krikamol Muandet, Kenji Fukumizu, Francesco Dinuzzo, and Bernhard Schlkopf. Learning from distributions via support measure machines. In P. Bartlett, FCN. Pereira, CJC. Burges, L. Bottou, and KQ. Weinberger (eds.), Advances in Neural Information Processing Systems 25, pp. 10–18. 2012. ",
+        "bbox": [
+            173,
+            584,
+            825,
+            638
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sinno Jialin Pan and Qiang Yang. A survey on transfer learning. Knowledge and Data Engineering, IEEE Transactions on, 22(10):1345–1359, 2010. ",
+        "bbox": [
+            173,
+            648,
+            821,
+            676
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Barnabas P ´ oczos, Liang Xiong, Dougal J Sutherland, and Jeff Schneider. Support distribution ma- ´ chines. Technical Report, 2012. URL http://arxiv.org/abs/1202.0302. ",
+        "bbox": [
+            173,
+            684,
+            821,
+            714
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rajesh Ranganath, Sean Gerrish, and David M Blei. Black box variational inference. In AISTATS, pp. 814–822, 2014. ",
+        "bbox": [
+            173,
+            722,
+            821,
+            751
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Proceedings of The 31st International Conference on Machine Learning, pp. 1278–1286, 2014. ",
+        "bbox": [
+            174,
+            758,
+            823,
+            801
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danilo Jimenez Rezende, Shakir Mohamed, Ivo Danihelka, Karol Gregor, and Daan Wierstra. Oneshot generalization in deep generative models. arXiv preprint arXiv:1603.05106, 2016. ",
+        "bbox": [
+            173,
+            808,
+            823,
+            837
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ruslan Salakhutdinov, Joshua B Tenenbaum, and Antonio Torralba. One-shot learning with a hierarchical nonparametric bayesian model. In ICML Unsupervised and Transfer Learning, pp. 195–206, 2012. ",
+        "bbox": [
+            173,
+            845,
+            821,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy Lillicrap. Oneshot learning with memory-augmented neural networks. arXiv preprint arXiv:1605.06065, 2016. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lawrence K Saul and Michael I Jordan. Exploiting tractable substructures in intractable networks. In Advances in Neural Processing Systems 8, 1996. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            131
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Theano Development Team. Theano: A Python framework for fast computation of mathematical expressions. arXiv e-prints, abs/1605.02688, May 2016. URL http://arxiv.org/abs/ 1605.02688. ",
+        "bbox": [
+            174,
+            146,
+            825,
+            188
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "L. Theis, A. van den Oord, and M. Bethge. A note on the evaluation of generative models. In International Conference on Learning Representations (ICLR), 2016. ",
+        "bbox": [
+            171,
+            202,
+            825,
+            231
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Samy Bengio, and Manjunath Kudlur. Order matters: sequence to sequence for sets. In International Conference on Learning Representations (ICLR), 2016a. ",
+        "bbox": [
+            174,
+            244,
+            823,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Koray Kavukcuoglu, and Daan Wierstra. Matching networks for one shot learning. arXiv preprint arXiv:1606.04080, 2016b. ",
+        "bbox": [
+            174,
+            287,
+            823,
+            316
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lior Wolf, Tal Hassner, and Itay Maoz. Face recognition in unconstrained videos with matched background similarity. In Computer Vision and Pattern Recognition (CVPR), 2011 IEEE Conference on, pp. 529–534. IEEE, 2011. ",
+        "bbox": [
+            174,
+            330,
+            825,
+            372
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX A: PSEUDOCODE ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            404,
+            444,
+            420
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Sampling a dataset of size $k$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            449,
+            447,
+            463
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "sample $c \\sim p ( c )$   \nfor $i = 1$ to $k$ do sample $z _ { i , L } \\sim p ( z _ { L } | c ; \\theta )$ for $j = L - 1$ to 1 do sample $z _ { i , j } \\sim p ( z _ { j } | z _ { i , j + 1 } , c ; \\theta )$ end for sample $x _ { i } \\sim p ( x | z _ { i , 1 } , . . . , z _ { i , L } , c ; \\theta )$   \nend for ",
+        "bbox": [
+            184,
+            467,
+            446,
+            574
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/9886ef231eb2027a4ce723d965da55746d8ce74e518610370bd4f5201b2c300f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm 2 Sampling a dataset of size k conditioned on a dataset of size m</td></tr><tr><td>μc,O² ← q(c|x1,...,Xm; Φ) {Calculate approximate posterior over c using statistic network.} c ← μc {Set c to be the mean of the approximate posterior.}</td></tr><tr><td>fori=1 to k do sample zi,L ~ p(zLlc; 0)</td></tr><tr><td>forj=L-1to1do</td></tr><tr><td>sample zi,j ~ p(zj|zi,j+1,C;0)</td></tr><tr><td>end for</td></tr><tr><td></td></tr><tr><td>sample xi ~p(x|zi,1,.., Zi,L,c;0)</td></tr></table>",
+        "bbox": [
+            179,
+            614,
+            818,
+            755
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 3 Selecting a representative sample of size $k$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            794,
+            542,
+            809
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "S ← {x1, . . . , xm}   \nI ← {1, . . . , m}   \nSI = {xi ∈ S : i ∈ I}   \n$N _ { S _ { I } }  q ( c | S _ { I } ; \\phi )$ {Calculate approximate posterior over $c$ using statistic network.}   \nfor $i = 1$ to $k$ do $\\begin{array} { l } { t \\gets a r g m i n _ { j \\in I } D _ { K L } \\left( N _ { S } \\| N _ { S _ { I - j } } \\right) } \\\\ { I \\gets I - t } \\end{array}$   \nend for ",
+        "bbox": [
+            187,
+            811,
+            743,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/8a5236f46fea97a381905c3c9ca833deca6a2e3dc39820fc8c66809e8d1396ee.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm4K-way few-shot classification</td></tr><tr><td>Do,...,Dk ← sets of labelled examples for each class</td></tr><tr><td>x ← datapoint to be classified</td></tr><tr><td>Nx ← q(c|x;) {approximate posterior over c given query point}</td></tr><tr><td>for i=1 to K do</td></tr><tr><td>Ni ← q(c|Di;Φ)</td></tr><tr><td>end for</td></tr><tr><td>y ←argminiDkL (NillNx)</td></tr></table>",
+        "bbox": [
+            173,
+            102,
+            825,
+            219
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B APPENDIX B: FURTHER EXPERIMENTAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            252,
+            622,
+            268
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.1 OMNIGLOT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            287,
+            295,
+            303
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shared encoder $x \\to h$ ",
+        "text_level": 1,
+        "bbox": [
+            183,
+            329,
+            343,
+            343
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "$\\overline { { 2 \\times \\left\\{ \\begin{array} { l } { c o n \\nu 2 d 6 4 } \\end{array} \\right. } }$ feature maps with $3 \\times 3$ kernels and ELU activations } conv2d 64 feature maps with $3 \\times 3$ kernels, stride 2 and ELU activations $2 \\times \\left\\{ c o n \\nu 2 d 1 2 \\ 8 \\right.$ feature maps with $3 \\times 3$ kernels and ELU activations $\\}$ conv2d 128 feature maps with $3 \\times 3$ kernels, stride 2 and ELU activations $2 \\times \\{ c o n \\nu 2 d 2 5 6$ feature maps with $3 \\times 3$ kernels and ELU activations $\\}$ conv2d 256 feature maps with $3 \\times 3$ kernels, stride 2 and ELU activations ",
+        "bbox": [
+            181,
+            344,
+            669,
+            424
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Statistic network $q ( c | D ; \\phi ) : h _ { 1 } , \\ldots , h _ { k } \\to \\mu _ { c } , \\sigma _ { c } ^ { 2 }$ fully-connected layer with 256 units and ELU activations sample-dropout and concatenation with number of samples average pooling within each dataset $2 \\times$ {fully-connected layer with 256 units and ELU activations $\\}$ fully-connected linear layers to $\\mu _ { c }$ and $\\log \\sigma _ { c } ^ { 2 }$ ",
+        "bbox": [
+            178,
+            468,
+            607,
+            553
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Inference network $q ( z | x , c ; \\phi ) : h , c \\to \\mu _ { z } , \\sigma _ { z } ^ { 2 }$ ",
+        "text_level": 1,
+        "bbox": [
+            181,
+            597,
+            495,
+            612
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "concatenate c and $\\overline { { h } }$ $3 \\times$ {fully-connected layer with 256 units and ELU activations $\\}$ fully-connected linear layers to $\\mu _ { z }$ and $\\log \\sigma _ { z } ^ { 2 }$ ",
+        "bbox": [
+            181,
+            614,
+            602,
+            654
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Latent decoder network $p ( z | c ; \\theta ) : c  \\mu _ { z } , \\sigma _ { z } ^ { 2 }$ $\\overline { { 3 \\times } }$ {fully-connected layer with 256 units and ELU activations } fully-connected linear layers to $\\mu _ { z }$ and $\\log \\sigma _ { z } ^ { 2 }$ ",
+        "bbox": [
+            179,
+            696,
+            609,
+            742
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Observation decoder network $p ( x | c , z ; \\theta ) : c , z \\to \\mu _ { x }$ ",
+        "text_level": 1,
+        "bbox": [
+            183,
+            786,
+            547,
+            801
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "concatenate $z$ and $c$ fully-connected linear layers with $4 \\cdot 4 \\cdot 2 5 6$ units $2 \\times \\ \\left\\{ \\begin{array} { r l } \\end{array} \\right.$ { conv2d 256 feature maps with $3 \\times 3$ kernels and ELU activations $\\}$ deconv2d 256 feature maps with $2 \\times 2$ kernels, stride 2, ELU activations $2 \\times \\left\\{ \\begin{array} { r l } \\end{array} \\right.$ { conv2d 128 feature maps with $3 \\times 3$ kernels and ELU activations $\\}$ deconv2d 128 feature maps with $2 \\times 2$ kernels, stride 2, ELU activations $2 \\times \\left\\{ \\begin{array} { r l } \\end{array} \\right.$ { conv2d 64 feature maps with $3 \\times 3$ kernels and ELU activations $\\}$ deconv $2 d 6 4$ feature maps with $2 \\times 2$ kernels, stride 2, ELU activations conv2d 1 feature map with $1 \\times 1$ kernels, sigmoid activations ",
+        "bbox": [
+            181,
+            803,
+            661,
+            920
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.2 YOUTUBE FACES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            334,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Shared encoder $x \\to h$ ",
+        "text_level": 1,
+        "bbox": [
+            183,
+            135,
+            343,
+            147
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "$\\overline { { 2 \\times \\{ \\ c o n \\nu 2 d \\} 3 2 } }$ feature maps with $\\overline { { 3 \\times 3 } }$ kernels and ELU activations $ { \\mathfrak { J } }$ conv2d 32 feature maps with $3 \\times 3$ kernels, stride 2 and ELU activations $2 \\times \\left\\{ c o n \\nu 2 d \\ : 6 4 \\right.$ feature maps with $3 \\times 3$ kernels and ELU activations $\\}$ conv2d 64 feature maps with $3 \\times 3$ kernels, stride 2 and ELU activations $2 \\times \\left\\{ \\begin{array} { l l } { c o n \\nu 2 d 1 2 8 } \\end{array} \\right.$ feature maps with $3 \\times 3$ kernels and ELU activations $\\}$ conv2d 128 feature maps with $3 \\times 3$ kernels, stride 2 and ELU activations $2 \\times \\{ c o n \\nu 2 d 2 5 6$ feature maps with $3 \\times 3$ kernels and ELU activations $\\}$ conv2d 256 feature maps with $3 \\times 3$ kernels, stride 2 and ELU activations ",
+        "bbox": [
+            181,
+            148,
+            669,
+            255
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Statistic network $q ( c | D , \\phi ) : h _ { 1 } , \\ldots , h _ { k } \\to \\mu _ { c } , \\sigma _ { c } ^ { 2 }$ fully-connected layer with 1000 units and ELU activations average pooling within each dataset fully-connected linear layers to $\\mu _ { c }$ and $\\log \\sigma _ { c } ^ { 2 }$ ",
+        "bbox": [
+            179,
+            285,
+            571,
+            342
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Inference network $q ( z | x , c , \\phi ) : h , c \\to \\mu _ { z } , \\sigma _ { z } ^ { 2 }$ concatenate c and $\\overline { { h } }$ fully-connected layer with 1000 units and ELU activations fully-connected linear layers to $\\mu _ { z }$ and $\\log \\sigma _ { z } ^ { 2 }$ ",
+        "bbox": [
+            181,
+            372,
+            495,
+            387
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            181,
+            390,
+            566,
+            429
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Latent decoder network $p ( z | c , ; \\theta ) : c  \\mu _ { z } , \\sigma _ { z } ^ { 2 }$ fully-connected layer with 1000 units and ELU activations fully-connected linear layers to $\\mu _ { z }$ and $\\log \\sigma _ { z } ^ { 2 }$ ",
+        "bbox": [
+            179,
+            459,
+            570,
+            502
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Observation decoder network $p ( x | c , z ; \\theta ) : c , z  \\mu _ { x }$ ",
+        "text_level": 1,
+        "bbox": [
+            181,
+            531,
+            547,
+            547
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "concatenate $z$ and $c$ fully-connected layer with 1000 units and ELU activations fully-connected linear layer with $8 \\cdot 8 \\cdot 2 5 6$ units $2 \\times \\left\\{ \\begin{array} { r l } \\end{array} \\right.$ { conv2d 256 feature maps with $3 \\times 3$ kernels and ELU activations $\\}$ deconv2d 256 feature maps with $2 \\times 2$ kernels, stride 2, ELU activations $2 \\times \\left\\{ \\begin{array} { r l } \\end{array} \\right.$ { conv2d 128 feature maps with $3 \\times 3$ kernels and ELU activations $\\}$ deconv2d 128 feature maps with $2 \\times 2$ kernels, stride 2, ELU activations $\\gtrsim \\gtrsim \\left\\{ c o n \\nu 2 d 6 4 \\right.$ feature maps with $3 \\times 3$ kernels and ELU activations $\\}$ deconv $2 d 6 4$ feature maps with $2 \\times 2$ kernels, stride 2, ELU activations $2 \\times \\left\\{ \\begin{array} { r l } \\end{array} \\right.$ { conv2d 32 feature maps with $3 \\times 3$ kernels and ELU activations $\\}$ deconv $2 d 3 2$ feature maps with $2 \\times 2$ kernels, stride 2, ELU activations conv2d 3 feature maps with $1 \\times 1$ kernels, sigmoid activations ",
+        "bbox": [
+            181,
+            549,
+            661,
+            707
+        ],
+        "page_idx": 12
+    }
+]

parse/train/HyzbhfWRW/HyzbhfWRW.md

@@ -0,0 +1,274 @@
+# LEARN TO PAY ATTENTION
+
+Saumya Jetley, Nicholas A. Lord, Namhoon Lee & Philip H. S. Torr Department of Engineering Science, University of Oxford {sjetley,nicklord,namhoon,phst}@robots.ox.ac.uk
+
+# ABSTRACT
+
+We propose an end-to-end-trainable attention module for convolutional neural network (CNN) architectures built for image classification. The module takes as input the 2D feature vector maps which form the intermediate representations of the input image at different stages in the CNN pipeline, and outputs a 2D matrix of scores for each map. Standard CNN architectures are modified through the incorporation of this module, and trained under the constraint that a convex combination of the intermediate 2D feature vectors, as parameterised by the score matrices, must alone be used for classification. Incentivised to amplify the relevant and suppress the irrelevant or misleading, the scores thus assume the role of attention values. Our experimental observations provide clear evidence to this effect: the learned attention maps neatly highlight the regions of interest while suppressing background clutter. Consequently, the proposed function is able to bootstrap standard CNN architectures for the task of image classification, demonstrating superior generalisation over 6 unseen benchmark datasets. When binarised, our attention maps outperform other CNN-based attention maps, traditional saliency maps, and top object proposals for weakly supervised segmentation as demonstrated on the Object Discovery dataset. We also demonstrate improved robustness against the fast gradient sign method of adversarial attack.
+
+# 1 INTRODUCTION
+
+Feed-forward convolutional neural networks (CNNs) have demonstrated impressive results on a wide variety of visual tasks, such as image classification, captioning, segmentation, and object detection. However, the visual reasoning which they implement in solving these problems remains largely inscrutable, impeding understanding of their successes and failures alike.
+
+One approach to visualising and interpreting the inner workings of CNNs is the attention map: a scalar matrix representing the relative importance of layer activations at different 2D spatial locations with respect to the target task (Simonyan et al., 2013). This notion of a nonuniform spatial distribution of relevant features being used to form a task-specific representation, and the explicit scalar representation of their relative relevance, is what we term ‘attention’. Previous works have shown that for a classification CNN trained using image-level annotations alone, extracting the attention map provides a straightforward way of determining the location of the object of interest (Cao et al., 2015; Zhou et al., 2016) and/or its segmentation mask (Simonyan et al., 2013), as well as helping to identify discriminative visual properties across classes (Zhou et al., 2016). More recently, it has also been shown that training smaller networks to mimic the attention maps of larger and higher-performing network architectures can lead to gains in classification accuracy of those smaller networks (Zagoruyko & Komodakis, 2016).
+
+The works of Simonyan et al. (2013); Cao et al. (2015); Zhou et al. (2016) represent one series of increasingly sophisticated techniques for estimating attention maps in classification CNNs. However, these approaches share a crucial limitation: all are implemented as post-hoc additions to fully trained networks. On the other hand, integrated attention mechanisms whose parameters are learned over the course of end-to-end training of the entire network have been proposed, and have shown benefits in various applications that can leverage attention as a cue. These include attribute prediction (Seo et al., 2016), machine translation (Bahdanau et al., 2014), image captioning (Xu et al., 2015; You et al., 2016; Mun et al., 2016) and visual question answering (VQA) (Xu & Saenko, 2016; Yang et al., 2016). Similarly to these approaches, we here represent attention as a probabilistic map over the input image locations, and implement its estimation via an end-to-end framework. The novelty of our contribution lies in repurposing the global image representation as a query to estimate multi-scale attention in classification, a task which, unlike e.g. image captioning or VQA, does not naturally involve a query.
+
+![](images/26815f0faa1e75e3765a2844154c24ccbae11c070196196fba138254b72a55f7.jpg)  
+Figure 1: Overview of the proposed attention mechanism.
+
+Fig. 1 provides an overview of the proposed method. Henceforth, we will use the terms ‘local features’ and ‘global features’ to refer to features extracted by some layer of the CNN whose effective receptive fields are, respectively, contiguous proper subsets of the image (‘local’) and the entire image (‘global’). By defining a compatibility measure between local and global features, we redesign standard architectures such that they must classify the input image using only a weighted combination of local features, with the weights represented here by the attention map. The network is thus forced to learn a pattern of attention relevant to solving the task at hand.
+
+We experiment with applying the proposed attention mechanism to the popular CNN architectures of VGGNet (Simonyan & Zisserman, 2014) and ResNet (He et al., 2015), and capturing coarse-to-fine attention maps at multiple levels. We observe that the proposed mechanism can bootstrap baseline CNN architectures for the task of image classification: for example, adding attention to the VGG model offers an accuracy gain of $7 \%$ on CIFAR-100. Our use of attention-weighted representations leads to improved fine-grained recognition and superior generalisation on 6 benchmark datasets for domain-shifted classification. As observed on models trained for fine-grained bird recognition, attention aware models offer limited resistance to adversarial fooling at low and moderate $L _ { \infty }$ -noise norms. The trained attention maps outperform other CNN-derived attention maps (Zhou et al., 2016), traditional saliency maps ( Jiang et al. (2013); Zhang & Sclaroff (2013)), and top object proposals on the task of weakly supervised segmentation of the Object Discovery dataset ( Rubinstein et al. (2013)). In §5, we present sample results which suggest that these improvements may owe to the method’s tendency to highlight the object of interest while suppressing background clutter.
+
+# 2 RELATED WORK
+
+Attention in CNNs is implemented using one of two main schemes - post hoc network analysis or trainable attention mechanisms. The former scheme has been predominantly employed to access network reasoning for the task of visual object recognition (Simonyan et al., 2013; Zhou et al., 2016; Cao et al., 2015). Simonyan et al. (2013) approximate CNNs as linear functions, interpreting the gradient of a class output score with respect to the input image as that class’s spatial support in the image domain, i.e. its attention map. Importantly, they are one of the first to successfully demonstrate the use of attention for localising objects of interest using image-level category labels alone. Zhou et al. (2016) apply the classifier weights learned for image-level descriptors to patch descriptors, and the resulting class scores are used as a proxy for attention. Their improved localisation performance comes at the cost of classification accuracy. Cao et al. (2015) introduce attention in the form of binary nodes between the network layers of Simonyan et al. (2013). At test time, these attention maps are adapted to a fully trained network in an additional parameter tuning step. Notably, all of the above methods extract attention from fully trained CNN classification models, i.e. via post-processing. Subsequently, as discussed shortly, many methods have explored the performance advantages of optimising the weights of the attention unit in tandem with the original network weights.
+
+Trainable attention in CNNs falls under two main categories - hard (stochastic) and soft (deterministic). In the former, a hard decision is made regarding the use of an image region, often represented by a low-order parameterisation, for inference (Mnih et al., 2014; Xu et al., 2015). The implementation is non-differentiable and relies on a sampling-based technique called REINFORCE for training, which makes optimising these models more difficult. On the other hand, the soft-attention method is probabilistic and thus amenable to training by backpropagation. The method of Jaderberg et al. (2015) lies at the intersection of the above two categories. It uses a parameterised transform to estimate hard attention on the input image deterministically, where the parameters of the image transformation are estimated using differentiable functions. The soft-attention method of Seo et al. (2016) demonstrates improvements over the above by implementing nonuniform non-rigid attention maps which are better suited to natural object shapes seen in real images. It is this direction that we explore in our current work.
+
+Trainable soft attention in CNNs has mainly been deployed for query-based tasks (Bahdanau et al., 2014; Xu et al., 2015; Seo et al., 2016; You et al., 2016; Mun et al., 2016; Xu & Saenko, 2016; Yang et al., 2016). As is done with the exemplar captions of Mun et al. (2016), the questions of $\mathrm { X u }$ & Saenko (2016); Yang et al. (2016), and the source sentences of Bahdanau et al. (2014), we here map an image to a high-dimensional representation which in turn highlights the relevant parts of the input image to guide the desired inference. We draw a close comparison to the progressive attention approach of Seo et al. (2016) for attribute prediction. However, there are some noteworthy differences. Their method uses a one-hot encoding of category labels to query the image: this is unavailable to us and we hence substitute a learned representation of the global image. In addition, their sequential mechanism refines a single attention map along the length of the network pipeline. This doesn’t allow for the expression of a complementary focus on different parts of the image at different scales as leveraged by our method, illustrated for the task of fine-grained recognition in $\ S 5$ .
+
+The applications of attention, in addition to facilitating the training task, are varied. The current work covers the following areas:
+
+· Domain shift: A traditional approach to handling domain shift in CNNs involves fine-tuning on the new dataset, which may require thousands of images from each target category for successful adaptation. We position ourselves amongst approaches that use attention (Zhou et al., 2016; Jaderberg et al., 2015) to better handle domain changes, particularly those involving background content, occlusion, and object pose variation, by selectively focusing to the objects of interest. Weakly supervised semantic segmentation: This area investigates image segmentation using minimal annotations in the form of scribbles, bounding boxes, or image-level category labels. Our work uses category labels and is related to the soft-attention approach of Hong et al. (2016). However, unlike the aformentioned, we do not explicitly train our model for the task of segmentation using any kind of pixel-level annotations. We evaluate the binarised spatial attention maps, learned as a by-product of training for image classification, for their ability to segment objects. · Adversarial robustness: The work by Goodfellow et al. (2014) explores the ease of fooling deep classification networks by adding an imperceptible perturbation to the input image, implemented as an epsilon step in the direction opposite to the predicted class score gradient. The works by Wang et al. (2016) and Gao et al. (2017) argue that this vulnerability comes from relying on spurious or non-oracle features for classification. Consequently, Gao et al. (2017) demonstrate increased adversarial robustness by identifying and masking the likely adversarial feature dimensions. We experiment with performing such suppression in the spatial domain.
+
+# 3 APPROACH
+
+The core goal of this work is to use attention maps to identify and exploit the effective spatial support of the visual information used by CNNs in making their classification decisions. This approach is premised on the hypothesis that there is benefit to identifying salient image regions and amplifying their influence, while likewise suppressing the irrelevant and potentially confusing information in other regions. In particular, we expect that enforcing a more focused and parsimonious use of image information should aid in generalisation over changes in the data distribution, as occurs for instance when training on one set and testing on another. Thus, we propose a trainable attention estimator and illustrate how to integrate it into standard CNN pipelines so as to influence their output as outlined above. The method is based on enforcing a notion of compatibility between local feature vectors extracted at intermediate stages in the CNN pipeline and the global feature vector normally fed to the linear classification layers at the end of the pipeline. We implement attention-aware classification by restricting the classifier to use only a collection of local feature vectors, as chosen and weighted by the compatibility scores, in classifying examples. We will first discuss the modification to the network architecture and the method of training it, given a choice of compatibility function. We will then conclude the method description by presenting alternate choices of the compatibility function.
+
+![](images/aa5193ce57171dde57d777a3d9e0d383710d2c54697ce6ec755e3f03f24e1f3c.jpg)  
+Figure 2: Attention introduced at 3 distinct layers of VGG. Lowest level attention maps appear to focus on the surroundings (i.e., the rocky mountain), intermediate level maps on object parts (i.e., harness and climbing equipment) and the highest level maps on the central object.
+
+# 3.1 DESIGN AND TRAINING OF ATTENTION SUBMODULE
+
+The proposed approach is illustrated in Fig. 2. Denote by $\mathcal { L } ^ { s } = \{ \ell _ { 1 } ^ { s } , \ell _ { 2 } ^ { s } , \cdot \cdot \cdot , \ell _ { n } ^ { s } \}$ the set of feature vectors extracted at a given convolutional layer $s \in \{ 1 , \cdots , S \}$ . Here, each $\ell _ { i } ^ { s }$ is the vector of output activations at the spatial location $i$ of $n$ total spatial locations in the layer. The global feature vector $\textbf {  { g } }$ has the entire input image as support and is output by the network’s series of convolutional and nonlinear layers, having only to pass through the final fully connected layers to produce the original architecture’s class score for that input. Assume for now the existence of a compatibility function $\mathcal { C }$ which takes two vectors of equal dimension as arguments and outputs a scalar compatibility score: this will be specified in 3.2.
+
+The method proceeds by computing, for each of one or more layers $s$ , the set of compatibility scores $\mathcal { C } ( \hat { \mathcal { L } } ^ { s } , \pmb { g } ) = \{ c _ { 1 } ^ { s } , c _ { 2 } ^ { s } , . . . c _ { n } ^ { s } \}$ , where $\hat { \mathcal { L } } ^ { s }$ is the image of $\mathcal { L } ^ { s }$ under a linear mapping of the $\ell _ { i } ^ { s }$ to the dimensionality of $\textbf {  { g } }$ . The compatibility scores are then normalised by a softmax operation:
+
+$$
+a _ { i } ^ { s } = \frac { \exp ( c _ { i } ^ { s } ) } { \sum _ { j } ^ { n } \exp ( c _ { j } ^ { s } ) } , i \in \{ 1 \cdot \cdot \cdot n \} .
+$$
+
+The normalised compatibility scores $\mathcal { A } ^ { s } = \{ a _ { 1 } ^ { s } , a _ { 2 } ^ { s } , \cdot \cdot \cdot a _ { n } ^ { s } \}$ are then used to produce a single vector $\begin{array} { r } { \pmb { g } _ { a } ^ { s } = \sum _ { i = 1 } ^ { n } a _ { i } ^ { s } \cdot \pmb { \ell } _ { i } ^ { s } } \end{array}$ for each layer $s$ , by simple element-wise weighted averaging. Crucially, the $\pmb { g } _ { a } ^ { s }$ now replace $\textbf {  { g } }$ as the global descriptor for the image. For a network trained under the restriction that the $\pmb { g } _ { a } ^ { s }$ alone are used to classify the input image, $\mathcal { A }$ corresponds to ‘attention’ as defined earlier.
+
+In the case of a single layer $S = 1 { \dot { } }$ ), the attention-incorporating global vector ${ \pmb g } _ { a }$ is computed as described above, then mapped onto a $T$ -dimensional vector which is passed through a softmax layer to obtain class prediction probabilities $\{ \hat { p } _ { 1 } , \hat { p } _ { 2 } , \cdot \cdot \cdot \hat { p } _ { T } \}$ , where $T$ is the number of target classes. In the case of multiple layers $( S > 1 )$ ), we compare two options: concatenating the global vectors into a single vector $\dot { { \pmb g } _ { a } } = \dot { [ { \pmb g } _ { a } ^ { 1 } , { \pmb g } _ { a } ^ { 2 } , \cdot \cdot \cdot { \pmb g } _ { a } ^ { S } ] }$ and using this as the input to the linear classification step as above, or, using $S$ different linear classifiers and averaging the output class probabilities. All free network parameters are learned in end-to-end training under a cross-entropy loss function.
+
+# 3.2 CHOICE OF COMPATIBILITY FUNCTION $\mathcal { C }$
+
+The compatibility score function $\mathcal { C }$ can be defined in various ways. The alignment model from Bahdanau et al. (2014); Xu et al. (2015) can be re-purposed as a compatibility function as follows:
+
+$$
+c _ { i } ^ { s } = \langle \pmb { u } , \pmb { \ell } _ { i } ^ { s } + \pmb { g } \rangle , i \in \{ 1 \cdots n \} ,
+$$
+
+Given the existing free parameters between the local and the global image descriptors in a CNN pipeline, we can simplify the concatenation of the two descriptors to an addition operation, without loss of generality. This allows us to limit the parameters of the attention unit. We then learn a single fully connected mapping from the resultant descriptor to the compatibility scores. Here, the weight vector $\textbf { \em u }$ can be interpreted as learning the universal set of features relevant to the object categories in the dataset. In that sense, the weights may be seen as learning the general concept of objectness.
+
+Alternatively, we can use the dot product between $\textbf {  { g } }$ and $\ell _ { i } ^ { s }$ as a measure of their compatibility:
+
+$$
+c _ { i } ^ { s } = \langle \ell _ { i } ^ { s } , g \rangle , i \in \{ 1 \cdot \cdot \cdot n \} .
+$$
+
+In this case, the relative magnitude of the scores would depend on the alignment between $\textbf {  { g } }$ and $\ell _ { i } ^ { s }$ in the high-dimensional feature space and the strength of activation of $\ell _ { i } ^ { s }$ .
+
+# 3.3 INTUITION
+
+In a standard CNN architecture, a global image descriptor $\textbf {  { g } }$ is derived from the input image and passed through a fully connected layer to obtain class prediction probabilities. The network must express $\textbf {  { g } }$ via mapping of the input into a high-dimensional space in which salient higher-order visual concepts are represented by different dimensions, so as to render the classes linearly separable from one another. Our method encourages the filters earlier in the CNN pipeline to learn similar mappings, compatible with the one that produces $\textbf {  { g } }$ in the original architecture. This is achieved by allowing a local descriptor $\ell _ { i }$ of an image patch to contribute to the final classification step only in proportion to its compatibility with $\textbf {  { g } }$ as detailed above. That is, $\mathcal { C } ( \hat { \ell } _ { i } , g )$ should be high if and only if the corresponding patch contains parts of the dominant image category. Note that this implies that the effective filters operating over image patches in the layers $s$ must represent relatively ‘mature’ features with respect to the classification goal. We thus expect to see the greatest benefit in deploying attention relatively late in the pipeline. Further, different kinds of class details are more easily accessible at different scales. Thus, in order to facilitate the learning of diverse and complementary attention-weighted features, we propose the use of attention over different spatial resolutions. The combination of the two factors stated above results in our deploying the attention units after the convolutional blocks that are late in the pipeline, but before their corresponding maxpooling operations, i.e. before a drop in the spatial resolution. Note also that the use of the softmax function in normalising the compatibility scores enforces $0 \leq a _ { i } \leq 1 \forall i \in \{ 1 \cdot \cdot \cdot n \}$ and $\textstyle \sum _ { i } a _ { i } = 1$ , i.e. that the combination of feature vectors is convex. This ensures that features at different spatial locations must effectively compete against one another for their share of the attention map. The compatibility scores thus serve as a robust proxy for attention in the classification pipeline.
+
+# 4 EXPERIMENTAL SETUP
+
+To incorporate attention into the VGG network, we move each of the first 2 max-pooling layers of the baseline architecture after each of the 2 corresponding additional convolutional layers that we introduce at the end of the pipeline. By pushing the pooling operations further down the pipeline, we ensure that the local layers used for estimating attention have a higher resolution. Our modified model has 17 layers: 15 convolutional and 2 fully connected. The output activations of layer16 (fc) define our global feature vector $\textbf {  { g } }$ . We use the local feature maps from layers 7, 10, and 13 (convolutional) for estimating attention. We compare our approach with the activation-based attention method of Zhou et al. (2016), and the progressive attention mechanism of Seo et al. (2016). For RNs (He et al., 2015), we use a 164-layered network. We replace the spatial average-pooling step after the computational block-4 with extra convolutional and max-pooling steps to obtain the global feature $\textbf {  { g } }$ . The outputs of blocks 2, 3, and 4 serve as the local descriptors for attention. For more details about network architectures refer to $\ S \mathrm { A } . 2$ . Note that, for both of the above architectures, if the dimensionality of $\textbf {  { g } }$ and the local features of a layer $s$ differ, we project $\textbf {  { g } }$ to the lower-dimensional space of the local features, instead of the reverse. This is done in order to limit the parameters at the classification stage. The global vector $\textbf {  { g } }$ , once mapped to a given dimensionality, is then shared by the local features from different layers $s$ as long as they are of that dimensionality.
+
+We refer to the network Net with attention at the last level as Net-att, at the last two levels as Net-att2, and at the last three levels as Net-att3. We denote by $d p$ the use of the dot product for matching the global and local descriptors and by $p c$ the use of parametrised compatibility. We denote by concat the concatenation of descriptors from different levels for the final linear classification step. We use indep to denote the alternative of independent prediction of probabilities at different levels using separate linear classifiers: these probabilities are averaged to obtain a single score per class.
+
+We evaluate the benefits of incorporating attention into CNNs for the primary tasks of image classification and fine-grained object category recognition. We also examine robustness to the kind of adversarial attack discussed by Goodfellow et al. (2014). Finally, we study the quality of attention maps as segmentations of image objects belonging to the network-predicted categories. For details of the datasets used and their pre-processing routines refer to $\ S \mathrm { A } . 1$ , for network training schedules refer to $\ S \mathrm { A } . 3$ , and for task-specific experimental setups refer to $\ S _ { \mathbf { A } . 4 }$ .
+
+# 5 RESULTS AND DISCUSSION
+
+5.1 IMAGE CLASSIFICATION AND FINE-GRAINED RECOGNITION   
+Table 1: CIFARs: Top-1 classification errors.   
+
+<table><tr><td>Model</td><td colspan="2">Top-1 error with standard deviation. CIFAR-10 CIFAR-100</td></tr><tr><td>Existing architectures-</td><td></td><td></td></tr><tr><td>VGG (Simonyan &amp; Zisserman, 2014)</td><td>7.77 (0.08)</td><td>30.62 (0.16)</td></tr><tr><td>VGG-GAP (Zhou et al.,2016)</td><td>9.87 (0.10)</td><td>31.77 (0.13)</td></tr><tr><td>VGG-PAN (Seo et al., 2016)</td><td>6.29 (0.03)</td><td>24.35 (0.14)</td></tr><tr><td>RN-164 (He et al., 2015)</td><td>6.03 (0.18)</td><td>25.34 (0.16)</td></tr><tr><td>—Architectureswith attention</td><td></td><td></td></tr><tr><td>(VGG-att)-dp</td><td>6.14 (0.06)</td><td>24.22 (0.08)</td></tr><tr><td>(VGG-att2)-indep-dp</td><td>5.91 (0.05)</td><td>23.24 (0.07)</td></tr><tr><td>(VGG-att2)-concat-dp</td><td>5.86 (0.05)</td><td>23.91 (0.11)</td></tr><tr><td>(VGG-att)-pc</td><td>5.67 (0.04)</td><td>23.70(0.07)</td></tr><tr><td>(VGG-att2)-indep-pc</td><td>5.36 (0.06)</td><td>24.00 (0.06)</td></tr><tr><td>(VGG-att2)-concat-pc</td><td>5.23 (0.04)</td><td>23.19 (0.04)</td></tr><tr><td>(VGG-att3)-concat-pc</td><td>6.34 (0.07)</td><td>22.97 (0.04)</td></tr></table>
+
+Table 2: Fine-grained recognition: Top-1 errors. \* denotes results from publications.   
+
+<table><tr><td>Model</td><td colspan="2">Top-1 error with standard deviation. CUB-200-2011 SVHN</td></tr><tr><td>-Existing architectures-</td><td></td><td></td></tr><tr><td>VGG (Simonyan &amp; Zisserman, 2014)</td><td>34.64 (0.26)</td><td>4.27 (0.04)</td></tr><tr><td>VGG-GAP (Zhou et al., 2016)</td><td>29.50*(-）</td><td>5.84 (0.09)</td></tr><tr><td>VGG-PAN (Seo et al.,2016)</td><td>31.46 (0.16)</td><td>8.02 (0.06)</td></tr><tr><td>RN-34 (Zagoruyko &amp; Komodakis,2016)</td><td>26.5*(-)</td><td></td></tr><tr><td>-Architectureswith attention-</td><td></td><td></td></tr><tr><td>(VGG-att2)-concat-pc</td><td>26.80 (0.16)</td><td>3.74 (0.05)</td></tr><tr><td>(VGG-att3)-concat-pc</td><td>26.95 (0.10)</td><td>3.52 (0.04)</td></tr></table>
+
+![](images/e132d6e372f4b5402f17ebc47533103915fd8842ba230995f17f0dad7cabfb68.jpg)  
+Figure 3: Attention maps from VGG-att2 trained on lowres CIFAR-10 dataset focus sharply on the objects in high-res ImageNet images of CIFAR categories; contrasted here with the activation-based attention maps of Zagoruyko & Komodakis (2016).
+
+![](images/7658ba123e61f037f1894b7718389be8a5cfc764e55f8b37222fe973705c70d8.jpg)  
+Figure 4: VGG-att2 trained on CUB-200 for fine-grained bird recognition task: layer-10 learns to fixate on eye and beak regions, layer-13 on plumage and feet.
+
+Within the standard VGG architecture, the proposed attention mechanism provides noticeable performance improvement over baseline models (e.g. VGG, RN) and existing attention mechanisms (e.g. GAP, PAN) for visual recognition tasks, as seen in Table 1 & 2. Specifically, the VGG-att2- concat-pc model achieves a $2 . 5 \%$ and $7 . 4 \%$ improvement over baseline VGG for CIFAR-10 and CIFAR-100 classification, and $7 . 8 \%$ and $0 . 5 \%$ improvement for fine-grained recognition of CUB and SVHN categories. As is evident from Fig. 3, the attention mechanism enables the network to focus on the object of interest while suppressing the background regions. For the task of fine-grained recognition, different layers learn specialised focus on different object parts as seen in Fig. 4. Note that the RN-34 model for CUB from Table 2 is pre-trained on ImageNet. In comparison, our networks are pre-trained using the much smaller and less diverse CIFAR-100. In spite of the low training cost, our networks are on par with the former in terms of accuracy. Importantly, despite the increase in the total network parameters due to the attention units, the proposed networks generalise exceedingly well to the test set. We are unable to compare directly with the CUB result of Jaderberg et al. (2015) due to a difference in dataset pre-processing. However, we improve over PAN (Seo et al., 2016) by $4 . 5 \%$ , which has itself been shown to outperform the former at a similar task. For the remaining experiments, concat-pc is our implicit attention design unless specified otherwise. When the same attention mechanism is introduced into RNs we observe a marginal drop in performance: $0 . 9 \%$ on CIFAR-10 and $1 . 5 \%$ on CIFAR-100. It is possible that the skip-connections in RNs work in a manner similar to the proposed attention mechanism, i.e. by allowing select local features from earlier layers to skip through and influence inference. While this might make the performance improvement due to attention redundant, our method, unlike the skip-connections, is able to provide explicit attention maps that can be used for auxiliary tasks such as weakly supervised segmentation.
+
+Finally, the global feature vector is used as a query in our attention calculations. By changing the query vector, one could expect to affect the predicted attention pattern. A brief investigation of the extent to which the two compatibility functions allow for such post-hoc control is provided in $\ S _ { \mathrm { A } . \ l } 5$ .
+
+# 5.2 ROBUSTNESS TO ADVERSARIAL ATTACK
+
+![](images/21dd22dd1ae5a5ae19a070ce7a16d544c71180b51a5a6ad255037ebf2b6c90bb.jpg)  
+Figure 5: Adversarial versions of a sample input image for log-linearly increasing $L _ { \infty }$ norm from 1 to 16, estimated for VGG and VGG-att2 trained on CUB-200.
+
+Figure 6: Network fooling rate measured as a percentage change in the predicted class labels w.r.t those predicted for the unperturbed images.   
+
+<table><tr><td rowspan="2">Lonorm</td><td colspan="2">Fooling rate</td></tr><tr><td>VGG</td><td>VGG-att2</td></tr><tr><td>1</td><td>58.58</td><td>53.78</td></tr><tr><td>2</td><td>78.27</td><td>76.00</td></tr><tr><td>4</td><td>89.99</td><td>89.90</td></tr><tr><td>8</td><td>94.89</td><td>95.27</td></tr><tr><td>16</td><td>96.46</td><td>97.60</td></tr></table>
+
+From Fig. 6, the fooling rate of attention-aware VGG is $5 \%$ less than the baseline VGG at an $L _ { \infty }$ noise norm of 1. As the noise norm increases, the fooling rate saturates for the two networks and the performance gap gradually decreases. Interestingly, when the noise begins to be perceptible (see Fig. 5, col. 5), the fooling rate of VGG-att2 is around a percentage higher than that of VGG.
+
+# 5.3 CROSS-DOMAIN IMAGE CLASSIFICATION
+
+<table><tr><td>Model</td><td colspan="7">Top-1 accuracies using models trained on CIFAR-10 /CIFAR-100.</td></tr><tr><td></td><td>STL-train</td><td>STL-test</td><td>Caltech-101</td><td>Caltech-256</td><td>Event-8</td><td>Action-40</td><td>Scene-67</td></tr><tr><td>-Existing archi.-</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>VGG (Simonyan &amp; Zisserman, 2014)</td><td>45.34/-</td><td>44.91/-</td><td>35.97 /54.20</td><td>13.16 /25.57</td><td>53.62/57.05</td><td>13.85 /17.58</td><td>11.02 /16.73</td></tr><tr><td>VGG-GAP (Zhou et al., 2016)</td><td>43.24/-</td><td>42.76/-</td><td>41.68 /62.61</td><td>16.30 /31.39</td><td>58.83 /68.11</td><td>16.73 /24.50</td><td>12.85 /23.04</td></tr><tr><td>VGG-PAN (Seo et al., 2016)</td><td>47.5/-</td><td>47.21/-</td><td>48.09 /65.75</td><td>19.61 /33.66</td><td>56.93 /64.49</td><td>16.96 /23.44</td><td>18.77 /23.43</td></tr><tr><td>RN-164 (He et al., 2015)</td><td>47.82/-</td><td>47.02/-</td><td>49.89 /73.62</td><td>22.59 /39.65</td><td>69.19 /75.10</td><td>20.56/28.72</td><td>20.26 /29.89</td></tr><tr><td>-Attention archi.</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>VGG-att2</td><td>48.76/-</td><td>48.29/-</td><td>55.96/74.40</td><td>26.54 /41.55</td><td>67.73/80.24</td><td>22.58 /29.95</td><td>25.43 /30.53</td></tr><tr><td>VGG-att3</td><td>48.42/-</td><td>48.32/-</td><td>58.34 /75.39</td><td>29.99 /44.14</td><td>77.06/82.08</td><td>26.75 /30.96</td><td>26.86/33.72</td></tr><tr><td>RN-164-att2</td><td>46.36/-</td><td>46.45/-</td><td>68.11 /79.17</td><td>36.33 /46.20</td><td>80.37 /83.67</td><td>30.47 /31.45</td><td>30.46 /34.39</td></tr></table>
+
+Table 3: Cross-domain classification: Top-1 accuracies using models trained on CIFAR-10/100.
+
+CIFAR images cover a wider variety of natural object categories compared to those of SVHN and CUB. Hence, we use these to train different network architectures and use the networks as offthe-shelf feature extractors to evaluate their generalisability to new unseen datasets. From Table 3, attention-aware models consistently improve over the baseline models, with an average margin of $6 \%$ . We make two additional observations. Firstly, low-resolution CIFAR images contain useful visual properties that are transferrable to high-resolution images such as the $6 0 0 \times 6 0 0$ images of the Event-8 dataset (Li & Fei-Fei, 2007). Secondly, training for diversity is better. CIFAR-10 and CIFAR-100 datasets contain the same corpus of images, only organised differently into 10 and 100 categories respectively. From the results in Table 3, and the attention maps of Fig. 7, it appears that while learning to distinguish a larger set of categories the network is able to highlight more nuanced image regions and capture features that better classify new datasets. (Note that the STL dataset shares the same category set as CIFAR-10. Hence, attention-mounted and baseline models are directly evaluated on STL without the use of an SVM.)
+
+![](images/8a0697cbb0b2a18590a39bdd256a42aa058c97686e06edd40cc4f7ed3df0080d.jpg)  
+Figure 7: Row 1 : Event-8 (croquet), Row 2 : Scene-67 (bar). Attention maps for models trained on CIFAR-100 (c100) are more diverse than those from the models trained on CIFAR-10 (c10). Note the sharp attention maps in col. 7 versus the uniform ones in col. 4. Attention maps at lower levels appear to attend to part details (e.g. the stack of wine bottles in the bar (row 2)) and at a higher level on whole objects owing to a large effective receptive field.
+
+# 5.4 WEAKLY SUPERVISED SEMANTIC SEGMENTATION
+
+<table><tr><td>Models</td><td>Airplane</td><td>Car</td><td>Horse</td></tr><tr><td>Attention-based</td><td></td><td></td><td></td></tr><tr><td>VGG-GAP (Zhou et al.,2016)</td><td>10.10/-</td><td>19.81/-</td><td>29.55/-</td></tr><tr><td>VGG-PAN (Seo et al., 2016)</td><td>31.91/31.24</td><td>28.21/27.45</td><td>25.57 /24.41</td></tr><tr><td>VGG-att2</td><td>34.98731.45</td><td>28.96738.99</td><td>29.29729.21</td></tr><tr><td>VGG-att3</td><td>48.07 /35.66</td><td>61.19 /41.23</td><td>40.95/29.68</td></tr><tr><td>RN-164-att2</td><td>41.01 /45.46</td><td>63.12/65.05</td><td>36.78 /40.36</td></tr><tr><td>—Saliency-based-</td><td></td><td></td><td></td></tr><tr><td>Jiang et al. (Jiang et al.,2013)</td><td>37.22</td><td>55.22</td><td>47.02</td></tr><tr><td>Zhang et al. (Zhang &amp; Sclaroff,2013)</td><td>51.84</td><td>46.61</td><td>39.52</td></tr><tr><td>一 -Topobject proposal-based</td><td></td><td></td><td></td></tr><tr><td>MCG (Arbeläez et al.,2014)</td><td>32.02</td><td>54.21</td><td>37.85</td></tr><tr><td>-Joint segmentation-based-</td><td></td><td></td><td></td></tr><tr><td>Joulin et al. (Joulin et al., 2010)</td><td>15.36</td><td>37.15</td><td>30.16</td></tr><tr><td>Object-discovery (Rubinstein et al., 2013)</td><td>55.81</td><td>64.42</td><td>51.65</td></tr><tr><td>Chen et al. (Chen et al., 2014)</td><td>54.62</td><td>69.20</td><td>44.46</td></tr><tr><td>Jain et al. (Dutt Jain &amp; Grauman,2016)</td><td>58.65</td><td>66.47</td><td>53.57</td></tr></table>
+
+![](images/ba49e16833b5d3a5b429f3e4423ac13553bac0cc10b052b7d1902085b85e9c71.jpg)  
+Figure 8: Weakly supervised segmentation by binarising attention maps.   
+Figure 9: Jaccard scores (higher is better) for binarised attention maps from CIFAR-10/100 trained models tested on the Object Discovery dataset.
+
+From Table 9, the proposed attention maps perform significantly better at weakly supervised segmentation than those obtained using the existing attention methods (Zhou et al., 2016; Seo et al., 2016) and compare favourably to the top object proposal method, outperforming for all three categories by a minimum margin of $1 1 \%$ and $3 \%$ respectively. We do not compare with the CNN-based object proposal methods as they are trained using additional bounding box annotations. We surpass the saliency-based methods in the car category, but perform less well for the other two categories of airplane and horse. This could be due to the detailed structure and smaller size of objects of the latter two categories, see Fig. 8. Finally, we perform single-image inference and yet compare well to the joint inference methods using a group of test images for segmenting the common object category.
+
+# 6 CONCLUSION
+
+We propose a trainable attention module for generating probabilistic landscapes that highlight where and in what proportion a network attends to different regions of the input image for the task of classification. We demonstrate that the method, when deployed at multiple levels within a network, affords significant performance gains in classification of seen and unseen categories by focusing on the object of interest. We also show that the attention landscapes can facilitate weakly supervised segmentation of the predominant object. Further, the proposed attention scheme is amenable to popular post-processing techniques such as conditional random fields for refining the segmentation masks, and has shown promise in learning robustness to certain kinds of adversarial attacks.
+
+Acknowledgements. This work was supported by the EPSRC, ERC grant ERC-2012- AdG 321162-HELIOS, EPSRC grant Seebibyte EP/M013774/1 and EPSRC/MURI grant EP/N019474/1.
+
+# REFERENCES
+
+Pablo Arbelaez, Jordi Pont-Tuset, Jonathan T Barron, Ferran Marques, and Jitendra Malik. Multiscale combi-´ natorial grouping. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 328–335, 2014.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.
+
+Chunshui Cao, Xianming Liu, Yi Yang, Yinan Yu, Jiang Wang, Zilei Wang, Yongzhen Huang, Liang Wang, Chang Huang, Wei Xu, Deva Ramanan, and Thomas S. Huang. Look and think twice: Capturing top-down visual attention with feedback convolutional neural networks. In ICCV, 2015.
+
+Xinlei Chen, Abhinav Shrivastava, and Abhinav Gupta. Enriching visual knowledge bases via object discovery and segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2027–2034, 2014.
+
+Adam Coates, Honglak Lee, and Andrew Y Ng. An analysis of single-layer networks in unsupervised feature learning [http://cs.stanford.edu/ acoates/stl10]. Ann Arbor, pp. 2, 2010.
+
+Suyog Dutt Jain and Kristen Grauman. Active image segmentation propagation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2864–2873, 2016.
+
+Li Fei-Fei, Rob Fergus, and Pietro Perona. One-shot learning of object categories. IEEE transactions on pattern analysis and machine intelligence, 28(4):594–611, 2006.
+
+Ji Gao, Beilun Wang, and Yanjun Qi. Deepmask: Masking DNN models for robustness against adversarial samples. CoRR, abs/1702.06763, 2017.
+
+Ian J. Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. CoRR, abs/1412.6572, 2014. URL http://arxiv.org/abs/1412.6572.
+
+Gregory Griffin, Alex Holub, and Pietro Perona. Caltech-256 object category dataset. 2007.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015.
+
+Seunghoon Hong, Junhyuk Oh, Honglak Lee, and Bohyung Han. Learning transferrable knowledge for semantic segmentation with deep convolutional neural network. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3204–3212, 2016.
+
+Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In Advances in Neural Information Processing Systems, pp. 2017–2025, 2015.
+
+Bowen Jiang, Lihe Zhang, Huchuan Lu, Chuan Yang, and Ming-Hsuan Yang. Saliency detection via absorbing markov chain. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1665–1672, 2013.
+
+Armand Joulin, Francis Bach, and Jean Ponce. Discriminative clustering for image co-segmentation. In Computer Vision and Pattern Recognition (CVPR), 2010 IEEE Conference on, pp. 1943–1950. IEEE, 2010.
+
+Armand Joulin, Francis Bach, and Jean Ponce. Multi-class cosegmentation. In Computer Vision and Pattern Recognition (CVPR), 2012 IEEE Conference on, pp. 542–549. IEEE, 2012.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Li-Jia Li and Li Fei-Fei. What, where and who? classifying events by scene and object recognition. In Computer Vision, 2007. ICCV 2007. IEEE 11th International Conference on, pp. 1–8. IEEE, 2007.
+
+Volodymyr Mnih, Nicolas Heess, Alex Graves, et al. Recurrent models of visual attention. In Advances in Neural Information Processing Systems, pp. 2204–2212, 2014.
+
+Jonghwan Mun, Minsu Cho, and Bohyung Han. Text-guided attention model for image captioning. CoRR, abs/1612.03557, 2016.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y. Ng. Reading digits in natural images with unsupervised feature learning. In NIPS Workshop on Deep Learning and Unsupervised Feature Learning 2011, 2011.
+
+Ariadna Quattoni and Antonio Torralba. Recognizing indoor scenes. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 413–420. IEEE, 2009.
+
+Joseph Redmon, Santosh Divvala, Ross Girshick, and Ali Farhadi. You only look once: Unified, real-time object detection. arXiv preprint arXiv:1506.02640, 2015.
+
+Michael Rubinstein, Armand Joulin, Johannes Kopf, and Ce Liu. Unsupervised joint object discovery and segmentation in internet images. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1939–1946, 2013.
+
+Paul Hongsuck Seo, Zhe Lin, Scott Cohen, Xiaohui Shen, and Bohyung Han. Hierarchical attention networks. CoRR, abs/1606.02393, 2016.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. arXiv preprint arXiv:1312.6034, 2013.
+
+C. Wah, S. Branson, P. Welinder, P. Perona, and S. Belongie. The Caltech-UCSD Birds-200-2011 Dataset. Technical report, California Institute of Technology, 2011.
+
+Beilun Wang, Ji Gao, and Yanjun Qi. A theoretical framework for robustness of (deep) classifiers under adversarial noise. arXiv preprint arXiv:1612.00334, 2016.
+
+Huijuan Xu and Kate Saenko. Ask, Attend and Answer: Exploring Question-Guided Spatial Attention for Visual Question Answering. Springer International Publishing, 2016.
+
+Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhutdinov, Richard Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In International Conference on Machine Learning (ICML) 2 (3), 5, 2015.
+
+Zichao Yang, Xiaodong He, Jianfeng Gao, li Deng, and Alex Smola. Stacked attention networks for image question answering, 06 2016.
+
+Bangpeng Yao, Xiaoye Jiang, Aditya Khosla, Andy Lai Lin, Leonidas Guibas, and Li Fei-Fei. Human action recognition by learning bases of action attributes and parts. In Computer Vision (ICCV), 2011 IEEE International Conference on, pp. 1331–1338. IEEE, 2011.
+
+Quanzeng You, Hailin Jin, Zhaowen Wang, Chen Fang, and Jiebo Luo. Image captioning with semantic attention. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4651–4659, 2016.
+
+Sergey Zagoruyko and Nikos Komodakis. Paying more attention to attention: Improving the performance of convolutional neural networks via attention transfer. CoRR, abs/1612.03928, 2016.
+
+Jianming Zhang and Stan Sclaroff. Saliency detection: A boolean map approach. In Proceedings of the IEEE international conference on computer vision, pp. 153–160, 2013.
+
+Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep features for discriminative localization. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2921–2929, 2016.
+
+# A APPENDICES
+
+# A.1 DATASETS
+
+We evaluate the proposed attention models on CIFAR-10 (Krizhevsky & Hinton, 2009), CIFAR100 (Krizhevsky & Hinton, 2009), SVHN (Netzer et al., 2011) and CUB-200-2011 (Wah et al., 2011) for the task of classification. We use the attention-incorporating VGG model trained on CUB200-2011 for investigating robustness to adversarial attacks. For cross-domain classification, we test on 6 standard benchmarks including STL (Coates et al., 2010), Caltech-256 (Griffin et al., 2007) and Action-40 (Yao et al., 2011). We use the Object Discovery dataset (Rubinstein et al., 2013) for evaluating weakly supervised segmentation performance. A detailed summary of these datasets can be found in Table 4.
+
+For all datasets except SVHN and CUB, we perform mean and standard deviation normalisation as well as colour normalisation. For CUB-200-2011, the images are cropped using ground-truth bounding box annotations and resized. For cross-domain image classification we downsample the input images to avoid the memory overhead.
+
+<table><tr><td>Dataset</td><td>Size (total/train/test/extra)</td><td>Number of classes /Type</td><td>Resolution</td><td>Tasks</td></tr><tr><td>CIFAR-10 (Krizhevsky&amp; Hinton,2009)</td><td>60,000 /50,000 /10,000 ／-</td><td>10 ／natural images</td><td>32x32</td><td>C,C-c,S</td></tr><tr><td>CIFAR-10O (Krizhevsky &amp; Hinton,2009)</td><td>60,000 /50,000 /10,000 ／-</td><td>100 ／natural images</td><td>32x32</td><td>C,C-c,S</td></tr><tr><td>SVHN (Netzer et al.,2011)</td><td>-/73,257 /26.032/531,131</td><td>10 /digits</td><td>32x32</td><td>C</td></tr><tr><td>CUB-200-2011(Wah et al., 2011)</td><td>-/5,994/5,794/-</td><td>200 /bird images</td><td>80x80</td><td>C</td></tr><tr><td>STL (Coates et al.,2010)</td><td>-/5,000/8,000/-</td><td>10/ImageNet images</td><td>96x96</td><td>C-c</td></tr><tr><td>Caltech-101 (Fei-Fei et al.,2006)</td><td>8677/-/-/-</td><td>101 /natural images</td><td>~300x200</td><td>C-c</td></tr><tr><td>Caltech-256 (Griffin et al.,2007)</td><td>29,780/-/-/-</td><td>256 /natural images</td><td>~300x200</td><td>C-c</td></tr><tr><td>Event-8 (Li&amp; Fei-Fei,2007)</td><td>1574/-/-/-</td><td>8 /in/out door sports</td><td>&gt;600x600</td><td>C-c</td></tr><tr><td>Action-40 (Yao et al., 2011)</td><td>9532/-/-/-</td><td>40 /natural images</td><td>~400x300</td><td>C-c</td></tr><tr><td>Scene-67(Quattoni &amp; Torralba,2009)</td><td>15613/-/-/-</td><td>67 /indoor scenes</td><td>~500x300</td><td>C-c</td></tr><tr><td>Object Discovery (Rubinstein et al., 2013)</td><td>300/-/300/-</td><td>3/synthetic and natural images</td><td>~340x240</td><td>C-c,S</td></tr></table>
+
+Table 4: Summary of datasets used for experiments across different tasks (C: classification, C-c: classification cross-domain, S: segmentation).The natural images span from those of objects in plain background to cluttered indoor and outdoor scenes. The objects vary from simple digits to humans involved in complex activities.
+
+# A.2 NETWORK ARCHITECTURES
+
+Progressive attention networks: We experiment with the progressive attention mechanism proposed by Seo et al. (2016) as part of our 2-level attention-based VGG models. The attention at the lower level (layer-10) is implemented using a 2D map of compatibility scores, obtained using the parameterised compatibility function discussed in $\ S 3 . 2$ . Note that at this level, the compatibility scores are not jointly normalised using the softmax operation, but are normalised independently using the pointwise sigmoid function. These scores, at each spatial location, are used to weigh the corresponding local features before the feature vectors are fed to the next network layer. This is the filtering operation at the core of the progressive attention scheme proposed by Seo et al. (2016). For the final level, attention is implemented in the same way as in VGG-att2-concat-pc. The compatibility scores are normalised using a softmax operation and the local features, added in proportion to the normalised attention scores, are trained for image classification.
+
+We implement and evaluate the above-discussed progressive attention approach as well as the proposed attention mechanism with the VGG architecture using the codebase provided here: https://github.com/szagoruyko/cifar.torch. The code for CIFAR dataset normalisation is included in the repository.
+
+Attention in ResNet: For the ResNet architecture, we make the attention-related modifications to the network specification provided here: https://github.com/szagoruyko/wide-residualnetworks/tree/fp16/models. The baseline ResNet implementation consists of 4 distinct levels that project the RGB input onto a 256-dimensional space through 16-, 64-, and 128-dimensional embedding spaces respectively. Each level excepting the first, which contains 2 convolutional layers separated by a non-linearity, contains $n$ -residual blocks. Each residual block in turn contains a maximum of 3 convolutional layers interleaved with non-linearities. This yields a network definition of
+
+$9 n + 2$ parameterised layers (He et al., 2015). We work with an $n$ of 18 for a 164-layered network.   
+Batch normalization is incorporated in a manner similar to other contemporary networks.
+
+We replace the spatial average pooling layer after the final and $4 ^ { t h }$ level by convolutional and maxpooling operations which gives us our global feature vector $\textbf {  { g } }$ . We refer to the network implementing attention at the output of the last level as RN-att and with attention at the output of last two levels as RN-att2. Following the results obtained on the VGG network, we train the attention units in the concat-pc framework.
+
+# A.3 TRAINING ROUTINES
+
+VGG networks for CIFAR-10, CIFAR-100 and SVHN are trained from scratch. We use a stochastic gradient descent (SGD) optimiser with a batch size of 128, learning rate decay of $1 0 ^ { - 7 }$ , weight decay of $5 \times 1 0 ^ { - 4 }$ , and momentum of 0.9. The initial learning rate for CIFAR experiments is 1 and for SVHN is 0.1. The learning rate is scaled by 0.5 every 25 epochs and we train over 300 epochs for convergence. For CUB, since the training data is limited, we initialise the model with the weights learned for CIFAR-100. We use the transfer-learning training schedule inspired by Redmon et al. (2015). Thus the training starts at a learning rate of 0.1 for first 30 epochs, is multiplied by 2 twice over the next 60 epochs, and then scaled by 0.5 every 30 epochs for the next 200 epochs.
+
+For ResNet, the networks are trained using an SGD optimizer with a batch size of 64, initial learning rate of 0.1, weight decay of $5 \times 1 0 ^ { - 4 }$ , and a momentum of 0.9. The learning rate is multiplied by 0.2 after 60, 120 and 160 epochs. The network is trained for 200 epochs until convergence. We train the models for CIFAR-10 and CIFAR-100 from scratch.
+
+All models are implemented in Torch and trained with an NVIDIA Titan-X GPU. Training takes around one to two days depending on the model and datasets.
+
+# A.4 TASK-SPECIFIC PROCESSING
+
+We generate the adversarial images using the fast gradient sign method of Goodfellow et al. (2014) and observe the network fooling behaviour at increasing $L _ { \infty }$ norms of the perturbations.
+
+For cross-domain classification, we extract features at the input of the final fully connected layer of each model, use these to train a linear SVM with $C \ = \ 1$ and report the results of a 5- fold cross validation, similar to the setup used by Zhou et al. (2016). At no point do we finetune the networks on the target datasets. We perform ZCA whitening on all the evaluation datasets using the pre-processing Python scripts specified in the following for whitening CIFAR datasets: https://github.com/szagoruyko/wide-residual-networks/tree/fp16.
+
+For weakly supervised segmentation, the evaluation datasets are preprocessed for colour normalisation using the same scheme as adopted for normalising the training datasets of the respective models. For the proposed attention mechanism, we combine the attention maps from the last 2 levels using element-wise multiplication, take the square root of the result to re-interpret it as a probability distribution (in the limit of the two probabilistic attention distributions approaching each other), rescale the values in the resultant map to a range of [0, 1] and binarise the map using the Otsu binarization threshold. For the progressive attention mechanism of Seo et al. (2016), we simply multiply the attention maps from the two different levels without taking their square root, given that these attention maps are not complementary but sequential maps used to fully develop the final attention distribution. The rest of the operations of magnitude rescaling and binarisation are commonly applied to all the final attention maps, including those obtained using GAP (Zhou et al., 2016).
+
+# A.5 QUERY-DRIVEN ATTENTION PATTERNS
+
+In our framework, the global feature vector is used as a query for estimating attention on the local image regions. Thus, by changing the global feature vector, one could expect to affect the attention distribution estimated over the local regions in a predictable manner. The extent to which the two different compatibility functions, the parameterised and the dot-product-based compatibility functions, allow for such external control over the estimated attention patterns may be varied.
+
+For the purpose of the analysis, we consider two different network architectures. The first is the (VGG-att2)-concat-dp (DP) model from Table 1 which uses a dot-product-based compatibility function. The other is the (VGG-att3)-concat-pc (PC) model which makes use of the parameterised compatibility function. In terms of the dataset, we make use of the extra cosegmentation image set available with the Object Discovery dataset package. We select a single image centrally focused on an instance of a given object category and call this the query image. We then gather a few distinct images that contain objects of the same category but in a more cluttered environment with pose and intra-class variations. We call these the target images.
+
+In order to visualise the role of the global feature vector in driving the estimated attention patterns, we perform two rounds of experiments. In the first round, we obtain both the global and local image feature vectors from a given target image, shown in column 2 of every row of Figure 10. The processing follows the standard protocol and the resulting attention patterns at layer 10 for the two architectures can be seen in columns 3 and 6 of the same figure. In the second round, we obtain the local feature vectors from the target image but the global feature vector is obtained by processing the query image specific to the category being considered, shown in column 1. The new attention patterns are displayed in columns 4 and 7 respectively. The changes in the attention values at different spatial locations as a proportion of the original attention pattern values are shown in columns 5 and 8 respectively.
+
+Notably, for the dot-product-based attention mechanism, the global vector plays a prominent role in guiding attention. This is visible in the increase in the attention magnitudes at the spatial locations near or related to the query image object. On the other hand, for the attention mechanism that makes use of the parameterised compatibility function, the global feature vector seems to be redundant. Any change in the global feature vector does not transfer to the resulting attention map. In fact, numerical observations show that the magnitudes of the global features are often a couple of orders of magnitude smaller than those of the corresponding local features. Thus, a change in the global feature vector has little to no impact on the predicted attention scores. Yet, the attention maps themselves are able to consistently highlight object-relevant image regions. Thus, it appears that in the case of parameterised compatibility based attention, the object-centric high-order features are learned as part of the weight vector $\textbf { \em u }$ . These features are adapted to the training dataset and are able to generalise to new images inasmuch as the object categories at test time are similar to those seen during training.
+
+![](images/2b2611a73097ff90aeaea799b4af3d80c3e4a758d3e9cda01343c223fb949b96.jpg)  
+Figure 10: Visual analysis of how a global feature vector obtained from a query image affects the attention patterns on the local image regions of another distinct target image.

parse/train/HyzbhfWRW/HyzbhfWRW_content_list.json

@@ -0,0 +1,1539 @@
+[
+    {
+        "type": "text",
+        "text": "LEARN TO PAY ATTENTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            503,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Saumya Jetley, Nicholas A. Lord, Namhoon Lee & Philip H. S. Torr Department of Engineering Science, University of Oxford {sjetley,nicklord,namhoon,phst}@robots.ox.ac.uk ",
+        "bbox": [
+            184,
+            143,
+            653,
+            188
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            224,
+            544,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose an end-to-end-trainable attention module for convolutional neural network (CNN) architectures built for image classification. The module takes as input the 2D feature vector maps which form the intermediate representations of the input image at different stages in the CNN pipeline, and outputs a 2D matrix of scores for each map. Standard CNN architectures are modified through the incorporation of this module, and trained under the constraint that a convex combination of the intermediate 2D feature vectors, as parameterised by the score matrices, must alone be used for classification. Incentivised to amplify the relevant and suppress the irrelevant or misleading, the scores thus assume the role of attention values. Our experimental observations provide clear evidence to this effect: the learned attention maps neatly highlight the regions of interest while suppressing background clutter. Consequently, the proposed function is able to bootstrap standard CNN architectures for the task of image classification, demonstrating superior generalisation over 6 unseen benchmark datasets. When binarised, our attention maps outperform other CNN-based attention maps, traditional saliency maps, and top object proposals for weakly supervised segmentation as demonstrated on the Object Discovery dataset. We also demonstrate improved robustness against the fast gradient sign method of adversarial attack. ",
+        "bbox": [
+            233,
+            256,
+            764,
+            503
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            530,
+            334,
+            546
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Feed-forward convolutional neural networks (CNNs) have demonstrated impressive results on a wide variety of visual tasks, such as image classification, captioning, segmentation, and object detection. However, the visual reasoning which they implement in solving these problems remains largely inscrutable, impeding understanding of their successes and failures alike. ",
+        "bbox": [
+            176,
+            563,
+            823,
+            617
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One approach to visualising and interpreting the inner workings of CNNs is the attention map: a scalar matrix representing the relative importance of layer activations at different 2D spatial locations with respect to the target task (Simonyan et al., 2013). This notion of a nonuniform spatial distribution of relevant features being used to form a task-specific representation, and the explicit scalar representation of their relative relevance, is what we term ‘attention’. Previous works have shown that for a classification CNN trained using image-level annotations alone, extracting the attention map provides a straightforward way of determining the location of the object of interest (Cao et al., 2015; Zhou et al., 2016) and/or its segmentation mask (Simonyan et al., 2013), as well as helping to identify discriminative visual properties across classes (Zhou et al., 2016). More recently, it has also been shown that training smaller networks to mimic the attention maps of larger and higher-performing network architectures can lead to gains in classification accuracy of those smaller networks (Zagoruyko & Komodakis, 2016). ",
+        "bbox": [
+            174,
+            625,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The works of Simonyan et al. (2013); Cao et al. (2015); Zhou et al. (2016) represent one series of increasingly sophisticated techniques for estimating attention maps in classification CNNs. However, these approaches share a crucial limitation: all are implemented as post-hoc additions to fully trained networks. On the other hand, integrated attention mechanisms whose parameters are learned over the course of end-to-end training of the entire network have been proposed, and have shown benefits in various applications that can leverage attention as a cue. These include attribute prediction (Seo et al., 2016), machine translation (Bahdanau et al., 2014), image captioning (Xu et al., 2015; You et al., 2016; Mun et al., 2016) and visual question answering (VQA) (Xu & Saenko, 2016; Yang et al., 2016). Similarly to these approaches, we here represent attention as a probabilistic map over the input image locations, and implement its estimation via an end-to-end framework. The novelty of our contribution lies in repurposing the global image representation as a query to estimate multi-scale attention in classification, a task which, unlike e.g. image captioning or VQA, does not naturally involve a query. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/26815f0faa1e75e3765a2844154c24ccbae11c070196196fba138254b72a55f7.jpg",
+        "image_caption": [
+            "Figure 1: Overview of the proposed attention mechanism. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            250,
+            104,
+            732,
+            258
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            319,
+            825,
+            375
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Fig. 1 provides an overview of the proposed method. Henceforth, we will use the terms ‘local features’ and ‘global features’ to refer to features extracted by some layer of the CNN whose effective receptive fields are, respectively, contiguous proper subsets of the image (‘local’) and the entire image (‘global’). By defining a compatibility measure between local and global features, we redesign standard architectures such that they must classify the input image using only a weighted combination of local features, with the weights represented here by the attention map. The network is thus forced to learn a pattern of attention relevant to solving the task at hand. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            479
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We experiment with applying the proposed attention mechanism to the popular CNN architectures of VGGNet (Simonyan & Zisserman, 2014) and ResNet (He et al., 2015), and capturing coarse-to-fine attention maps at multiple levels. We observe that the proposed mechanism can bootstrap baseline CNN architectures for the task of image classification: for example, adding attention to the VGG model offers an accuracy gain of $7 \\%$ on CIFAR-100. Our use of attention-weighted representations leads to improved fine-grained recognition and superior generalisation on 6 benchmark datasets for domain-shifted classification. As observed on models trained for fine-grained bird recognition, attention aware models offer limited resistance to adversarial fooling at low and moderate $L _ { \\infty }$ -noise norms. The trained attention maps outperform other CNN-derived attention maps (Zhou et al., 2016), traditional saliency maps ( Jiang et al. (2013); Zhang & Sclaroff (2013)), and top object proposals on the task of weakly supervised segmentation of the Object Discovery dataset ( Rubinstein et al. (2013)). In §5, we present sample results which suggest that these improvements may owe to the method’s tendency to highlight the object of interest while suppressing background clutter. ",
+        "bbox": [
+            174,
+            486,
+            825,
+            667
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            694,
+            344,
+            709
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Attention in CNNs is implemented using one of two main schemes - post hoc network analysis or trainable attention mechanisms. The former scheme has been predominantly employed to access network reasoning for the task of visual object recognition (Simonyan et al., 2013; Zhou et al., 2016; Cao et al., 2015). Simonyan et al. (2013) approximate CNNs as linear functions, interpreting the gradient of a class output score with respect to the input image as that class’s spatial support in the image domain, i.e. its attention map. Importantly, they are one of the first to successfully demonstrate the use of attention for localising objects of interest using image-level category labels alone. Zhou et al. (2016) apply the classifier weights learned for image-level descriptors to patch descriptors, and the resulting class scores are used as a proxy for attention. Their improved localisation performance comes at the cost of classification accuracy. Cao et al. (2015) introduce attention in the form of binary nodes between the network layers of Simonyan et al. (2013). At test time, these attention maps are adapted to a fully trained network in an additional parameter tuning step. Notably, all of the above methods extract attention from fully trained CNN classification models, i.e. via post-processing. Subsequently, as discussed shortly, many methods have explored the performance advantages of optimising the weights of the attention unit in tandem with the original network weights. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Trainable attention in CNNs falls under two main categories - hard (stochastic) and soft (deterministic). In the former, a hard decision is made regarding the use of an image region, often represented by a low-order parameterisation, for inference (Mnih et al., 2014; Xu et al., 2015). The implementation is non-differentiable and relies on a sampling-based technique called REINFORCE for training, which makes optimising these models more difficult. On the other hand, the soft-attention method is probabilistic and thus amenable to training by backpropagation. The method of Jaderberg et al. (2015) lies at the intersection of the above two categories. It uses a parameterised transform to estimate hard attention on the input image deterministically, where the parameters of the image transformation are estimated using differentiable functions. The soft-attention method of Seo et al. (2016) demonstrates improvements over the above by implementing nonuniform non-rigid attention maps which are better suited to natural object shapes seen in real images. It is this direction that we explore in our current work. ",
+        "bbox": [
+            174,
+            136,
+            825,
+            303
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Trainable soft attention in CNNs has mainly been deployed for query-based tasks (Bahdanau et al., 2014; Xu et al., 2015; Seo et al., 2016; You et al., 2016; Mun et al., 2016; Xu & Saenko, 2016; Yang et al., 2016). As is done with the exemplar captions of Mun et al. (2016), the questions of $\\mathrm { X u }$ & Saenko (2016); Yang et al. (2016), and the source sentences of Bahdanau et al. (2014), we here map an image to a high-dimensional representation which in turn highlights the relevant parts of the input image to guide the desired inference. We draw a close comparison to the progressive attention approach of Seo et al. (2016) for attribute prediction. However, there are some noteworthy differences. Their method uses a one-hot encoding of category labels to query the image: this is unavailable to us and we hence substitute a learned representation of the global image. In addition, their sequential mechanism refines a single attention map along the length of the network pipeline. This doesn’t allow for the expression of a complementary focus on different parts of the image at different scales as leveraged by our method, illustrated for the task of fine-grained recognition in $\\ S 5$ . ",
+        "bbox": [
+            174,
+            308,
+            825,
+            474
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The applications of attention, in addition to facilitating the training task, are varied. The current work covers the following areas: ",
+        "bbox": [
+            176,
+            478,
+            821,
+            507
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "· Domain shift: A traditional approach to handling domain shift in CNNs involves fine-tuning on the new dataset, which may require thousands of images from each target category for successful adaptation. We position ourselves amongst approaches that use attention (Zhou et al., 2016; Jaderberg et al., 2015) to better handle domain changes, particularly those involving background content, occlusion, and object pose variation, by selectively focusing to the objects of interest. Weakly supervised semantic segmentation: This area investigates image segmentation using minimal annotations in the form of scribbles, bounding boxes, or image-level category labels. Our work uses category labels and is related to the soft-attention approach of Hong et al. (2016). However, unlike the aformentioned, we do not explicitly train our model for the task of segmentation using any kind of pixel-level annotations. We evaluate the binarised spatial attention maps, learned as a by-product of training for image classification, for their ability to segment objects. · Adversarial robustness: The work by Goodfellow et al. (2014) explores the ease of fooling deep classification networks by adding an imperceptible perturbation to the input image, implemented as an epsilon step in the direction opposite to the predicted class score gradient. The works by Wang et al. (2016) and Gao et al. (2017) argue that this vulnerability comes from relying on spurious or non-oracle features for classification. Consequently, Gao et al. (2017) demonstrate increased adversarial robustness by identifying and masking the likely adversarial feature dimensions. We experiment with performing such suppression in the spatial domain. ",
+        "bbox": [
+            183,
+            508,
+            825,
+            761
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            781,
+            297,
+            796
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The core goal of this work is to use attention maps to identify and exploit the effective spatial support of the visual information used by CNNs in making their classification decisions. This approach is premised on the hypothesis that there is benefit to identifying salient image regions and amplifying their influence, while likewise suppressing the irrelevant and potentially confusing information in other regions. In particular, we expect that enforcing a more focused and parsimonious use of image information should aid in generalisation over changes in the data distribution, as occurs for instance when training on one set and testing on another. Thus, we propose a trainable attention estimator and illustrate how to integrate it into standard CNN pipelines so as to influence their output as outlined above. The method is based on enforcing a notion of compatibility between local feature vectors extracted at intermediate stages in the CNN pipeline and the global feature vector normally fed to the linear classification layers at the end of the pipeline. We implement attention-aware classification by restricting the classifier to use only a collection of local feature vectors, as chosen and weighted by the compatibility scores, in classifying examples. We will first discuss the modification to the network architecture and the method of training it, given a choice of compatibility function. We will then conclude the method description by presenting alternate choices of the compatibility function. ",
+        "bbox": [
+            174,
+            813,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/aa5193ce57171dde57d777a3d9e0d383710d2c54697ce6ec755e3f03f24e1f3c.jpg",
+        "image_caption": [
+            "Figure 2: Attention introduced at 3 distinct layers of VGG. Lowest level attention maps appear to focus on the surroundings (i.e., the rocky mountain), intermediate level maps on object parts (i.e., harness and climbing equipment) and the highest level maps on the central object. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            215,
+            103,
+            745,
+            284
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            375,
+            825,
+            473
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 DESIGN AND TRAINING OF ATTENTION SUBMODULE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            501,
+            576,
+            515
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The proposed approach is illustrated in Fig. 2. Denote by $\\mathcal { L } ^ { s } = \\{ \\ell _ { 1 } ^ { s } , \\ell _ { 2 } ^ { s } , \\cdot \\cdot \\cdot , \\ell _ { n } ^ { s } \\}$ the set of feature vectors extracted at a given convolutional layer $s \\in \\{ 1 , \\cdots , S \\}$ . Here, each $\\ell _ { i } ^ { s }$ is the vector of output activations at the spatial location $i$ of $n$ total spatial locations in the layer. The global feature vector $\\textbf {  { g } }$ has the entire input image as support and is output by the network’s series of convolutional and nonlinear layers, having only to pass through the final fully connected layers to produce the original architecture’s class score for that input. Assume for now the existence of a compatibility function $\\mathcal { C }$ which takes two vectors of equal dimension as arguments and outputs a scalar compatibility score: this will be specified in 3.2. ",
+        "bbox": [
+            173,
+            530,
+            825,
+            642
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The method proceeds by computing, for each of one or more layers $s$ , the set of compatibility scores $\\mathcal { C } ( \\hat { \\mathcal { L } } ^ { s } , \\pmb { g } ) = \\{ c _ { 1 } ^ { s } , c _ { 2 } ^ { s } , . . . c _ { n } ^ { s } \\}$ , where $\\hat { \\mathcal { L } } ^ { s }$ is the image of $\\mathcal { L } ^ { s }$ under a linear mapping of the $\\ell _ { i } ^ { s }$ to the dimensionality of $\\textbf {  { g } }$ . The compatibility scores are then normalised by a softmax operation: ",
+        "bbox": [
+            173,
+            648,
+            825,
+            694
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b1718042f68cfa8a5ef757d3484d92ed2eefc006ec2125c1c837f785aa2ec2f1.jpg",
+        "text": "$$\na _ { i } ^ { s } = \\frac { \\exp ( c _ { i } ^ { s } ) } { \\sum _ { j } ^ { n } \\exp ( c _ { j } ^ { s } ) } , i \\in \\{ 1 \\cdot \\cdot \\cdot n \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            710,
+            611,
+            747
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The normalised compatibility scores $\\mathcal { A } ^ { s } = \\{ a _ { 1 } ^ { s } , a _ { 2 } ^ { s } , \\cdot \\cdot \\cdot a _ { n } ^ { s } \\}$ are then used to produce a single vector $\\begin{array} { r } { \\pmb { g } _ { a } ^ { s } = \\sum _ { i = 1 } ^ { n } a _ { i } ^ { s } \\cdot \\pmb { \\ell } _ { i } ^ { s } } \\end{array}$ for each layer $s$ , by simple element-wise weighted averaging. Crucially, the $\\pmb { g } _ { a } ^ { s }$ now replace $\\textbf {  { g } }$ as the global descriptor for the image. For a network trained under the restriction that the $\\pmb { g } _ { a } ^ { s }$ alone are used to classify the input image, $\\mathcal { A }$ corresponds to ‘attention’ as defined earlier. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            820
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the case of a single layer $S = 1 { \\dot { } }$ ), the attention-incorporating global vector ${ \\pmb g } _ { a }$ is computed as described above, then mapped onto a $T$ -dimensional vector which is passed through a softmax layer to obtain class prediction probabilities $\\{ \\hat { p } _ { 1 } , \\hat { p } _ { 2 } , \\cdot \\cdot \\cdot \\hat { p } _ { T } \\}$ , where $T$ is the number of target classes. In the case of multiple layers $( S > 1 )$ ), we compare two options: concatenating the global vectors into a single vector $\\dot { { \\pmb g } _ { a } } = \\dot { [ { \\pmb g } _ { a } ^ { 1 } , { \\pmb g } _ { a } ^ { 2 } , \\cdot \\cdot \\cdot { \\pmb g } _ { a } ^ { S } ] }$ and using this as the input to the linear classification step as above, or, using $S$ different linear classifiers and averaging the output class probabilities. All free network parameters are learned in end-to-end training under a cross-entropy loss function. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 CHOICE OF COMPATIBILITY FUNCTION $\\mathcal { C }$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            495,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The compatibility score function $\\mathcal { C }$ can be defined in various ways. The alignment model from Bahdanau et al. (2014); Xu et al. (2015) can be re-purposed as a compatibility function as follows: ",
+        "bbox": [
+            171,
+            128,
+            821,
+            159
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f88de2e14c33d1e82cb8a4a4c5fd098f5da501dc2e2e6a842b7bdf4bace65e72.jpg",
+        "text": "$$\nc _ { i } ^ { s } = \\langle \\pmb { u } , \\pmb { \\ell } _ { i } ^ { s } + \\pmb { g } \\rangle , i \\in \\{ 1 \\cdots n \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            165,
+            604,
+            183
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given the existing free parameters between the local and the global image descriptors in a CNN pipeline, we can simplify the concatenation of the two descriptors to an addition operation, without loss of generality. This allows us to limit the parameters of the attention unit. We then learn a single fully connected mapping from the resultant descriptor to the compatibility scores. Here, the weight vector $\\textbf { \\em u }$ can be interpreted as learning the universal set of features relevant to the object categories in the dataset. In that sense, the weights may be seen as learning the general concept of objectness. ",
+        "bbox": [
+            174,
+            189,
+            825,
+            273
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Alternatively, we can use the dot product between $\\textbf {  { g } }$ and $\\ell _ { i } ^ { s }$ as a measure of their compatibility: ",
+        "bbox": [
+            171,
+            280,
+            797,
+            295
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4621860fbc93b2b76b637b218fa9e9c6e9accc0affe56c16970fec21ed8e3174.jpg",
+        "text": "$$\nc _ { i } ^ { s } = \\langle \\ell _ { i } ^ { s } , g \\rangle , i \\in \\{ 1 \\cdot \\cdot \\cdot n \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            301,
+            589,
+            319
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this case, the relative magnitude of the scores would depend on the alignment between $\\textbf {  { g } }$ and $\\ell _ { i } ^ { s }$ in the high-dimensional feature space and the strength of activation of $\\ell _ { i } ^ { s }$ . ",
+        "bbox": [
+            171,
+            325,
+            823,
+            354
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 INTUITION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            371,
+            289,
+            386
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In a standard CNN architecture, a global image descriptor $\\textbf {  { g } }$ is derived from the input image and passed through a fully connected layer to obtain class prediction probabilities. The network must express $\\textbf {  { g } }$ via mapping of the input into a high-dimensional space in which salient higher-order visual concepts are represented by different dimensions, so as to render the classes linearly separable from one another. Our method encourages the filters earlier in the CNN pipeline to learn similar mappings, compatible with the one that produces $\\textbf {  { g } }$ in the original architecture. This is achieved by allowing a local descriptor $\\ell _ { i }$ of an image patch to contribute to the final classification step only in proportion to its compatibility with $\\textbf {  { g } }$ as detailed above. That is, $\\mathcal { C } ( \\hat { \\ell } _ { i } , g )$ should be high if and only if the corresponding patch contains parts of the dominant image category. Note that this implies that the effective filters operating over image patches in the layers $s$ must represent relatively ‘mature’ features with respect to the classification goal. We thus expect to see the greatest benefit in deploying attention relatively late in the pipeline. Further, different kinds of class details are more easily accessible at different scales. Thus, in order to facilitate the learning of diverse and complementary attention-weighted features, we propose the use of attention over different spatial resolutions. The combination of the two factors stated above results in our deploying the attention units after the convolutional blocks that are late in the pipeline, but before their corresponding maxpooling operations, i.e. before a drop in the spatial resolution. Note also that the use of the softmax function in normalising the compatibility scores enforces $0 \\leq a _ { i } \\leq 1 \\forall i \\in \\{ 1 \\cdot \\cdot \\cdot n \\}$ and $\\textstyle \\sum _ { i } a _ { i } = 1$ , i.e. that the combination of feature vectors is convex. This ensures that features at different spatial locations must effectively compete against one another for their share of the attention map. The compatibility scores thus serve as a robust proxy for attention in the classification pipeline. ",
+        "bbox": [
+            173,
+            396,
+            825,
+            691
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            712,
+            398,
+            727
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To incorporate attention into the VGG network, we move each of the first 2 max-pooling layers of the baseline architecture after each of the 2 corresponding additional convolutional layers that we introduce at the end of the pipeline. By pushing the pooling operations further down the pipeline, we ensure that the local layers used for estimating attention have a higher resolution. Our modified model has 17 layers: 15 convolutional and 2 fully connected. The output activations of layer16 (fc) define our global feature vector $\\textbf {  { g } }$ . We use the local feature maps from layers 7, 10, and 13 (convolutional) for estimating attention. We compare our approach with the activation-based attention method of Zhou et al. (2016), and the progressive attention mechanism of Seo et al. (2016). For RNs (He et al., 2015), we use a 164-layered network. We replace the spatial average-pooling step after the computational block-4 with extra convolutional and max-pooling steps to obtain the global feature $\\textbf {  { g } }$ . The outputs of blocks 2, 3, and 4 serve as the local descriptors for attention. For more details about network architectures refer to $\\ S \\mathrm { A } . 2$ . Note that, for both of the above architectures, if the dimensionality of $\\textbf {  { g } }$ and the local features of a layer $s$ differ, we project $\\textbf {  { g } }$ to the lower-dimensional space of the local features, instead of the reverse. This is done in order to limit the parameters at the classification stage. The global vector $\\textbf {  { g } }$ , once mapped to a given dimensionality, is then shared by the local features from different layers $s$ as long as they are of that dimensionality. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We refer to the network Net with attention at the last level as Net-att, at the last two levels as Net-att2, and at the last three levels as Net-att3. We denote by $d p$ the use of the dot product for matching the global and local descriptors and by $p c$ the use of parametrised compatibility. We denote by concat the concatenation of descriptors from different levels for the final linear classification step. We use indep to denote the alternative of independent prediction of probabilities at different levels using separate linear classifiers: these probabilities are averaged to obtain a single score per class. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            236
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the benefits of incorporating attention into CNNs for the primary tasks of image classification and fine-grained object category recognition. We also examine robustness to the kind of adversarial attack discussed by Goodfellow et al. (2014). Finally, we study the quality of attention maps as segmentations of image objects belonging to the network-predicted categories. For details of the datasets used and their pre-processing routines refer to $\\ S \\mathrm { A } . 1$ , for network training schedules refer to $\\ S \\mathrm { A } . 3$ , and for task-specific experimental setups refer to $\\ S _ { \\mathbf { A } . 4 }$ . ",
+        "bbox": [
+            174,
+            243,
+            825,
+            327
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 RESULTS AND DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            349,
+            428,
+            364
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/528e2d0c18a0590018b6c28deaf01b127ac0f6f1b2275d4a96e43b9b4ed202a8.jpg",
+        "table_caption": [
+            "5.1 IMAGE CLASSIFICATION AND FINE-GRAINED RECOGNITION ",
+            "Table 1: CIFARs: Top-1 classification errors. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td colspan=\"2\">Top-1 error with standard deviation. CIFAR-10 CIFAR-100</td></tr><tr><td>Existing architectures-</td><td></td><td></td></tr><tr><td>VGG (Simonyan &amp; Zisserman, 2014)</td><td>7.77 (0.08)</td><td>30.62 (0.16)</td></tr><tr><td>VGG-GAP (Zhou et al.,2016)</td><td>9.87 (0.10)</td><td>31.77 (0.13)</td></tr><tr><td>VGG-PAN (Seo et al., 2016)</td><td>6.29 (0.03)</td><td>24.35 (0.14)</td></tr><tr><td>RN-164 (He et al., 2015)</td><td>6.03 (0.18)</td><td>25.34 (0.16)</td></tr><tr><td>—Architectureswith attention</td><td></td><td></td></tr><tr><td>(VGG-att)-dp</td><td>6.14 (0.06)</td><td>24.22 (0.08)</td></tr><tr><td>(VGG-att2)-indep-dp</td><td>5.91 (0.05)</td><td>23.24 (0.07)</td></tr><tr><td>(VGG-att2)-concat-dp</td><td>5.86 (0.05)</td><td>23.91 (0.11)</td></tr><tr><td>(VGG-att)-pc</td><td>5.67 (0.04)</td><td>23.70(0.07)</td></tr><tr><td>(VGG-att2)-indep-pc</td><td>5.36 (0.06)</td><td>24.00 (0.06)</td></tr><tr><td>(VGG-att2)-concat-pc</td><td>5.23 (0.04)</td><td>23.19 (0.04)</td></tr><tr><td>(VGG-att3)-concat-pc</td><td>6.34 (0.07)</td><td>22.97 (0.04)</td></tr></table>",
+        "bbox": [
+            174,
+            411,
+            464,
+            537
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/ef33019e02d5ceadacc90a5e169bd322a3588c33f8158802dfad723de59e98e2.jpg",
+        "table_caption": [
+            "Table 2: Fine-grained recognition: Top-1 errors. \\* denotes results from publications. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td colspan=\"2\">Top-1 error with standard deviation. CUB-200-2011 SVHN</td></tr><tr><td>-Existing architectures-</td><td></td><td></td></tr><tr><td>VGG (Simonyan &amp; Zisserman, 2014)</td><td>34.64 (0.26)</td><td>4.27 (0.04)</td></tr><tr><td>VGG-GAP (Zhou et al., 2016)</td><td>29.50*(-）</td><td>5.84 (0.09)</td></tr><tr><td>VGG-PAN (Seo et al.,2016)</td><td>31.46 (0.16)</td><td>8.02 (0.06)</td></tr><tr><td>RN-34 (Zagoruyko &amp; Komodakis,2016)</td><td>26.5*(-)</td><td></td></tr><tr><td>-Architectureswith attention-</td><td></td><td></td></tr><tr><td>(VGG-att2)-concat-pc</td><td>26.80 (0.16)</td><td>3.74 (0.05)</td></tr><tr><td>(VGG-att3)-concat-pc</td><td>26.95 (0.10)</td><td>3.52 (0.04)</td></tr></table>",
+        "bbox": [
+            493,
+            417,
+            810,
+            512
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/e132d6e372f4b5402f17ebc47533103915fd8842ba230995f17f0dad7cabfb68.jpg",
+        "image_caption": [
+            "Figure 3: Attention maps from VGG-att2 trained on lowres CIFAR-10 dataset focus sharply on the objects in high-res ImageNet images of CIFAR categories; contrasted here with the activation-based attention maps of Zagoruyko & Komodakis (2016). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            233,
+            587,
+            488,
+            714
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/7658ba123e61f037f1894b7718389be8a5cfc764e55f8b37222fe973705c70d8.jpg",
+        "image_caption": [
+            "Figure 4: VGG-att2 trained on CUB-200 for fine-grained bird recognition task: layer-10 learns to fixate on eye and beak regions, layer-13 on plumage and feet. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            583,
+            588,
+            722,
+            713
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Within the standard VGG architecture, the proposed attention mechanism provides noticeable performance improvement over baseline models (e.g. VGG, RN) and existing attention mechanisms (e.g. GAP, PAN) for visual recognition tasks, as seen in Table 1 & 2. Specifically, the VGG-att2- concat-pc model achieves a $2 . 5 \\%$ and $7 . 4 \\%$ improvement over baseline VGG for CIFAR-10 and CIFAR-100 classification, and $7 . 8 \\%$ and $0 . 5 \\%$ improvement for fine-grained recognition of CUB and SVHN categories. As is evident from Fig. 3, the attention mechanism enables the network to focus on the object of interest while suppressing the background regions. For the task of fine-grained recognition, different layers learn specialised focus on different object parts as seen in Fig. 4. Note that the RN-34 model for CUB from Table 2 is pre-trained on ImageNet. In comparison, our networks are pre-trained using the much smaller and less diverse CIFAR-100. In spite of the low training cost, our networks are on par with the former in terms of accuracy. Importantly, despite the increase in the total network parameters due to the attention units, the proposed networks generalise exceedingly well to the test set. We are unable to compare directly with the CUB result of Jaderberg et al. (2015) due to a difference in dataset pre-processing. However, we improve over PAN (Seo et al., 2016) by $4 . 5 \\%$ , which has itself been shown to outperform the former at a similar task. For the remaining experiments, concat-pc is our implicit attention design unless specified otherwise. When the same attention mechanism is introduced into RNs we observe a marginal drop in performance: $0 . 9 \\%$ on CIFAR-10 and $1 . 5 \\%$ on CIFAR-100. It is possible that the skip-connections in RNs work in a manner similar to the proposed attention mechanism, i.e. by allowing select local features from earlier layers to skip through and influence inference. While this might make the performance improvement due to attention redundant, our method, unlike the skip-connections, is able to provide explicit attention maps that can be used for auxiliary tasks such as weakly supervised segmentation. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            299
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, the global feature vector is used as a query in our attention calculations. By changing the query vector, one could expect to affect the predicted attention pattern. A brief investigation of the extent to which the two compatibility functions allow for such post-hoc control is provided in $\\ S _ { \\mathrm { A } . \\ l } 5$ . ",
+        "bbox": [
+            174,
+            305,
+            825,
+            347
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 ROBUSTNESS TO ADVERSARIAL ATTACK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            364,
+            493,
+            377
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/21dd22dd1ae5a5ae19a070ce7a16d544c71180b51a5a6ad255037ebf2b6c90bb.jpg",
+        "image_caption": [
+            "Figure 5: Adversarial versions of a sample input image for log-linearly increasing $L _ { \\infty }$ norm from 1 to 16, estimated for VGG and VGG-att2 trained on CUB-200. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            230,
+            395,
+            472,
+            472
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/8485492f323faa7f6a4312f019e7c9548b1aeaa85da8f57ae6d67bc98980a64b.jpg",
+        "table_caption": [
+            "Figure 6: Network fooling rate measured as a percentage change in the predicted class labels w.r.t those predicted for the unperturbed images. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Lonorm</td><td colspan=\"2\">Fooling rate</td></tr><tr><td>VGG</td><td>VGG-att2</td></tr><tr><td>1</td><td>58.58</td><td>53.78</td></tr><tr><td>2</td><td>78.27</td><td>76.00</td></tr><tr><td>4</td><td>89.99</td><td>89.90</td></tr><tr><td>8</td><td>94.89</td><td>95.27</td></tr><tr><td>16</td><td>96.46</td><td>97.60</td></tr></table>",
+        "bbox": [
+            609,
+            392,
+            758,
+            460
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "From Fig. 6, the fooling rate of attention-aware VGG is $5 \\%$ less than the baseline VGG at an $L _ { \\infty }$ noise norm of 1. As the noise norm increases, the fooling rate saturates for the two networks and the performance gap gradually decreases. Interestingly, when the noise begins to be perceptible (see Fig. 5, col. 5), the fooling rate of VGG-att2 is around a percentage higher than that of VGG. ",
+        "bbox": [
+            174,
+            542,
+            823,
+            599
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 CROSS-DOMAIN IMAGE CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            616,
+            493,
+            630
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/be326ee2b18b9e8dcecf1b171c3087e85fe99628056c4ea5b94b3c370666923e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td colspan=\"7\">Top-1 accuracies using models trained on CIFAR-10 /CIFAR-100.</td></tr><tr><td></td><td>STL-train</td><td>STL-test</td><td>Caltech-101</td><td>Caltech-256</td><td>Event-8</td><td>Action-40</td><td>Scene-67</td></tr><tr><td>-Existing archi.-</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>VGG (Simonyan &amp; Zisserman, 2014)</td><td>45.34/-</td><td>44.91/-</td><td>35.97 /54.20</td><td>13.16 /25.57</td><td>53.62/57.05</td><td>13.85 /17.58</td><td>11.02 /16.73</td></tr><tr><td>VGG-GAP (Zhou et al., 2016)</td><td>43.24/-</td><td>42.76/-</td><td>41.68 /62.61</td><td>16.30 /31.39</td><td>58.83 /68.11</td><td>16.73 /24.50</td><td>12.85 /23.04</td></tr><tr><td>VGG-PAN (Seo et al., 2016)</td><td>47.5/-</td><td>47.21/-</td><td>48.09 /65.75</td><td>19.61 /33.66</td><td>56.93 /64.49</td><td>16.96 /23.44</td><td>18.77 /23.43</td></tr><tr><td>RN-164 (He et al., 2015)</td><td>47.82/-</td><td>47.02/-</td><td>49.89 /73.62</td><td>22.59 /39.65</td><td>69.19 /75.10</td><td>20.56/28.72</td><td>20.26 /29.89</td></tr><tr><td>-Attention archi.</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>VGG-att2</td><td>48.76/-</td><td>48.29/-</td><td>55.96/74.40</td><td>26.54 /41.55</td><td>67.73/80.24</td><td>22.58 /29.95</td><td>25.43 /30.53</td></tr><tr><td>VGG-att3</td><td>48.42/-</td><td>48.32/-</td><td>58.34 /75.39</td><td>29.99 /44.14</td><td>77.06/82.08</td><td>26.75 /30.96</td><td>26.86/33.72</td></tr><tr><td>RN-164-att2</td><td>46.36/-</td><td>46.45/-</td><td>68.11 /79.17</td><td>36.33 /46.20</td><td>80.37 /83.67</td><td>30.47 /31.45</td><td>30.46 /34.39</td></tr></table>",
+        "bbox": [
+            214,
+            643,
+            784,
+            744
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Cross-domain classification: Top-1 accuracies using models trained on CIFAR-10/100. ",
+        "bbox": [
+            181,
+            755,
+            810,
+            768
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "CIFAR images cover a wider variety of natural object categories compared to those of SVHN and CUB. Hence, we use these to train different network architectures and use the networks as offthe-shelf feature extractors to evaluate their generalisability to new unseen datasets. From Table 3, attention-aware models consistently improve over the baseline models, with an average margin of $6 \\%$ . We make two additional observations. Firstly, low-resolution CIFAR images contain useful visual properties that are transferrable to high-resolution images such as the $6 0 0 \\times 6 0 0$ images of the Event-8 dataset (Li & Fei-Fei, 2007). Secondly, training for diversity is better. CIFAR-10 and CIFAR-100 datasets contain the same corpus of images, only organised differently into 10 and 100 categories respectively. From the results in Table 3, and the attention maps of Fig. 7, it appears that while learning to distinguish a larger set of categories the network is able to highlight more nuanced image regions and capture features that better classify new datasets. (Note that the STL dataset shares the same category set as CIFAR-10. Hence, attention-mounted and baseline models are directly evaluated on STL without the use of an SVM.) ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/8a0697cbb0b2a18590a39bdd256a42aa058c97686e06edd40cc4f7ed3df0080d.jpg",
+        "image_caption": [
+            "Figure 7: Row 1 : Event-8 (croquet), Row 2 : Scene-67 (bar). Attention maps for models trained on CIFAR-100 (c100) are more diverse than those from the models trained on CIFAR-10 (c10). Note the sharp attention maps in col. 7 versus the uniform ones in col. 4. Attention maps at lower levels appear to attend to part details (e.g. the stack of wine bottles in the bar (row 2)) and at a higher level on whole objects owing to a large effective receptive field. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            101,
+            764,
+            208
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            314,
+            825,
+            356
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 WEAKLY SUPERVISED SEMANTIC SEGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            376,
+            558,
+            387
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/97560806c9274925299e28054c9de09e909128dd983f4a3eff78d6da0087c91e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>Airplane</td><td>Car</td><td>Horse</td></tr><tr><td>Attention-based</td><td></td><td></td><td></td></tr><tr><td>VGG-GAP (Zhou et al.,2016)</td><td>10.10/-</td><td>19.81/-</td><td>29.55/-</td></tr><tr><td>VGG-PAN (Seo et al., 2016)</td><td>31.91/31.24</td><td>28.21/27.45</td><td>25.57 /24.41</td></tr><tr><td>VGG-att2</td><td>34.98731.45</td><td>28.96738.99</td><td>29.29729.21</td></tr><tr><td>VGG-att3</td><td>48.07 /35.66</td><td>61.19 /41.23</td><td>40.95/29.68</td></tr><tr><td>RN-164-att2</td><td>41.01 /45.46</td><td>63.12/65.05</td><td>36.78 /40.36</td></tr><tr><td>—Saliency-based-</td><td></td><td></td><td></td></tr><tr><td>Jiang et al. (Jiang et al.,2013)</td><td>37.22</td><td>55.22</td><td>47.02</td></tr><tr><td>Zhang et al. (Zhang &amp; Sclaroff,2013)</td><td>51.84</td><td>46.61</td><td>39.52</td></tr><tr><td>一 -Topobject proposal-based</td><td></td><td></td><td></td></tr><tr><td>MCG (Arbeläez et al.,2014)</td><td>32.02</td><td>54.21</td><td>37.85</td></tr><tr><td>-Joint segmentation-based-</td><td></td><td></td><td></td></tr><tr><td>Joulin et al. (Joulin et al., 2010)</td><td>15.36</td><td>37.15</td><td>30.16</td></tr><tr><td>Object-discovery (Rubinstein et al., 2013)</td><td>55.81</td><td>64.42</td><td>51.65</td></tr><tr><td>Chen et al. (Chen et al., 2014)</td><td>54.62</td><td>69.20</td><td>44.46</td></tr><tr><td>Jain et al. (Dutt Jain &amp; Grauman,2016)</td><td>58.65</td><td>66.47</td><td>53.57</td></tr></table>",
+        "bbox": [
+            442,
+            407,
+            815,
+            561
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/ba49e16833b5d3a5b429f3e4423ac13553bac0cc10b052b7d1902085b85e9c71.jpg",
+        "image_caption": [
+            "Figure 8: Weakly supervised segmentation by binarising attention maps. ",
+            "Figure 9: Jaccard scores (higher is better) for binarised attention maps from CIFAR-10/100 trained models tested on the Object Discovery dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            405,
+            400,
+            564
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "From Table 9, the proposed attention maps perform significantly better at weakly supervised segmentation than those obtained using the existing attention methods (Zhou et al., 2016; Seo et al., 2016) and compare favourably to the top object proposal method, outperforming for all three categories by a minimum margin of $1 1 \\%$ and $3 \\%$ respectively. We do not compare with the CNN-based object proposal methods as they are trained using additional bounding box annotations. We surpass the saliency-based methods in the car category, but perform less well for the other two categories of airplane and horse. This could be due to the detailed structure and smaller size of objects of the latter two categories, see Fig. 8. Finally, we perform single-image inference and yet compare well to the joint inference methods using a group of test images for segmenting the common object category. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            760
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            780,
+            318,
+            796
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We propose a trainable attention module for generating probabilistic landscapes that highlight where and in what proportion a network attends to different regions of the input image for the task of classification. We demonstrate that the method, when deployed at multiple levels within a network, affords significant performance gains in classification of seen and unseen categories by focusing on the object of interest. We also show that the attention landscapes can facilitate weakly supervised segmentation of the predominant object. Further, the proposed attention scheme is amenable to popular post-processing techniques such as conditional random fields for refining the segmentation masks, and has shown promise in learning robustness to certain kinds of adversarial attacks. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements. This work was supported by the EPSRC, ERC grant ERC-2012- AdG 321162-HELIOS, EPSRC grant Seebibyte EP/M013774/1 and EPSRC/MURI grant EP/N019474/1. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            143
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            162,
+            287,
+            179
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pablo Arbelaez, Jordi Pont-Tuset, Jonathan T Barron, Ferran Marques, and Jitendra Malik. Multiscale combi-´ natorial grouping. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 328–335, 2014. ",
+        "bbox": [
+            174,
+            185,
+            825,
+            223
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014. ",
+        "bbox": [
+            171,
+            233,
+            823,
+            260
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chunshui Cao, Xianming Liu, Yi Yang, Yinan Yu, Jiang Wang, Zilei Wang, Yongzhen Huang, Liang Wang, Chang Huang, Wei Xu, Deva Ramanan, and Thomas S. Huang. Look and think twice: Capturing top-down visual attention with feedback convolutional neural networks. In ICCV, 2015. ",
+        "bbox": [
+            174,
+            268,
+            823,
+            308
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xinlei Chen, Abhinav Shrivastava, and Abhinav Gupta. Enriching visual knowledge bases via object discovery and segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2027–2034, 2014. ",
+        "bbox": [
+            173,
+            316,
+            821,
+            356
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Adam Coates, Honglak Lee, and Andrew Y Ng. An analysis of single-layer networks in unsupervised feature learning [http://cs.stanford.edu/ acoates/stl10]. Ann Arbor, pp. 2, 2010. ",
+        "bbox": [
+            173,
+            364,
+            823,
+            392
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Suyog Dutt Jain and Kristen Grauman. Active image segmentation propagation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2864–2873, 2016. ",
+        "bbox": [
+            176,
+            400,
+            825,
+            428
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Li Fei-Fei, Rob Fergus, and Pietro Perona. One-shot learning of object categories. IEEE transactions on pattern analysis and machine intelligence, 28(4):594–611, 2006. ",
+        "bbox": [
+            176,
+            435,
+            823,
+            463
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ji Gao, Beilun Wang, and Yanjun Qi. Deepmask: Masking DNN models for robustness against adversarial samples. CoRR, abs/1702.06763, 2017. ",
+        "bbox": [
+            174,
+            470,
+            821,
+            498
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian J. Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. CoRR, abs/1412.6572, 2014. URL http://arxiv.org/abs/1412.6572. ",
+        "bbox": [
+            169,
+            507,
+            821,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gregory Griffin, Alex Holub, and Pietro Perona. Caltech-256 object category dataset. 2007. ",
+        "bbox": [
+            176,
+            542,
+            717,
+            556
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015. ",
+        "bbox": [
+            171,
+            565,
+            821,
+            592
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Seunghoon Hong, Junhyuk Oh, Honglak Lee, and Bohyung Han. Learning transferrable knowledge for semantic segmentation with deep convolutional neural network. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3204–3212, 2016. ",
+        "bbox": [
+            173,
+            601,
+            821,
+            640
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In Advances in Neural Information Processing Systems, pp. 2017–2025, 2015. ",
+        "bbox": [
+            173,
+            648,
+            823,
+            676
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bowen Jiang, Lihe Zhang, Huchuan Lu, Chuan Yang, and Ming-Hsuan Yang. Saliency detection via absorbing markov chain. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1665–1672, 2013. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            723
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Armand Joulin, Francis Bach, and Jean Ponce. Discriminative clustering for image co-segmentation. In Computer Vision and Pattern Recognition (CVPR), 2010 IEEE Conference on, pp. 1943–1950. IEEE, 2010. ",
+        "bbox": [
+            171,
+            732,
+            823,
+            760
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Armand Joulin, Francis Bach, and Jean Ponce. Multi-class cosegmentation. In Computer Vision and Pattern Recognition (CVPR), 2012 IEEE Conference on, pp. 542–549. IEEE, 2012. ",
+        "bbox": [
+            171,
+            767,
+            823,
+            795
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            169,
+            803,
+            766,
+            818
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Li-Jia Li and Li Fei-Fei. What, where and who? classifying events by scene and object recognition. In Computer Vision, 2007. ICCV 2007. IEEE 11th International Conference on, pp. 1–8. IEEE, 2007. ",
+        "bbox": [
+            171,
+            827,
+            823,
+            853
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Nicolas Heess, Alex Graves, et al. Recurrent models of visual attention. In Advances in Neural Information Processing Systems, pp. 2204–2212, 2014. ",
+        "bbox": [
+            174,
+            862,
+            821,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jonghwan Mun, Minsu Cho, and Bohyung Han. Text-guided attention model for image captioning. CoRR, abs/1612.03557, 2016. ",
+        "bbox": [
+            171,
+            897,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y. Ng. Reading digits in natural images with unsupervised feature learning. In NIPS Workshop on Deep Learning and Unsupervised Feature Learning 2011, 2011. ",
+        "bbox": [
+            174,
+            104,
+            823,
+            143
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ariadna Quattoni and Antonio Torralba. Recognizing indoor scenes. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 413–420. IEEE, 2009. ",
+        "bbox": [
+            171,
+            151,
+            821,
+            179
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Joseph Redmon, Santosh Divvala, Ross Girshick, and Ali Farhadi. You only look once: Unified, real-time object detection. arXiv preprint arXiv:1506.02640, 2015. ",
+        "bbox": [
+            173,
+            188,
+            821,
+            213
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Rubinstein, Armand Joulin, Johannes Kopf, and Ce Liu. Unsupervised joint object discovery and segmentation in internet images. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1939–1946, 2013. ",
+        "bbox": [
+            174,
+            222,
+            823,
+            262
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Paul Hongsuck Seo, Zhe Lin, Scott Cohen, Xiaohui Shen, and Bohyung Han. Hierarchical attention networks. CoRR, abs/1606.02393, 2016. ",
+        "bbox": [
+            171,
+            270,
+            823,
+            296
+        ],
+        "page_idx": 9
+    },
+    {
+        "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,
+            305,
+            821,
+            333
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. arXiv preprint arXiv:1312.6034, 2013. ",
+        "bbox": [
+            173,
+            340,
+            821,
+            367
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "C. Wah, S. Branson, P. Welinder, P. Perona, and S. Belongie. The Caltech-UCSD Birds-200-2011 Dataset. Technical report, California Institute of Technology, 2011. ",
+        "bbox": [
+            174,
+            376,
+            823,
+            404
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Beilun Wang, Ji Gao, and Yanjun Qi. A theoretical framework for robustness of (deep) classifiers under adversarial noise. arXiv preprint arXiv:1612.00334, 2016. ",
+        "bbox": [
+            174,
+            411,
+            823,
+            438
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Huijuan Xu and Kate Saenko. Ask, Attend and Answer: Exploring Question-Guided Spatial Attention for Visual Question Answering. Springer International Publishing, 2016. ",
+        "bbox": [
+            173,
+            445,
+            823,
+            473
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhutdinov, Richard Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In International Conference on Machine Learning (ICML) 2 (3), 5, 2015. ",
+        "bbox": [
+            174,
+            481,
+            823,
+            521
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zichao Yang, Xiaodong He, Jianfeng Gao, li Deng, and Alex Smola. Stacked attention networks for image question answering, 06 2016. ",
+        "bbox": [
+            171,
+            529,
+            823,
+            556
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bangpeng Yao, Xiaoye Jiang, Aditya Khosla, Andy Lai Lin, Leonidas Guibas, and Li Fei-Fei. Human action recognition by learning bases of action attributes and parts. In Computer Vision (ICCV), 2011 IEEE International Conference on, pp. 1331–1338. IEEE, 2011. ",
+        "bbox": [
+            174,
+            564,
+            823,
+            604
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Quanzeng You, Hailin Jin, Zhaowen Wang, Chen Fang, and Jiebo Luo. Image captioning with semantic attention. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4651–4659, 2016. ",
+        "bbox": [
+            173,
+            612,
+            823,
+            651
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Paying more attention to attention: Improving the performance of convolutional neural networks via attention transfer. CoRR, abs/1612.03928, 2016. ",
+        "bbox": [
+            174,
+            660,
+            821,
+            686
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jianming Zhang and Stan Sclaroff. Saliency detection: A boolean map approach. In Proceedings of the IEEE international conference on computer vision, pp. 153–160, 2013. ",
+        "bbox": [
+            169,
+            695,
+            823,
+            722
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep features for discriminative localization. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2921–2929, 2016. ",
+        "bbox": [
+            174,
+            731,
+            823,
+            770
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A APPENDICES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            316,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            132,
+            290,
+            147
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the proposed attention models on CIFAR-10 (Krizhevsky & Hinton, 2009), CIFAR100 (Krizhevsky & Hinton, 2009), SVHN (Netzer et al., 2011) and CUB-200-2011 (Wah et al., 2011) for the task of classification. We use the attention-incorporating VGG model trained on CUB200-2011 for investigating robustness to adversarial attacks. For cross-domain classification, we test on 6 standard benchmarks including STL (Coates et al., 2010), Caltech-256 (Griffin et al., 2007) and Action-40 (Yao et al., 2011). We use the Object Discovery dataset (Rubinstein et al., 2013) for evaluating weakly supervised segmentation performance. A detailed summary of these datasets can be found in Table 4. ",
+        "bbox": [
+            174,
+            159,
+            825,
+            270
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For all datasets except SVHN and CUB, we perform mean and standard deviation normalisation as well as colour normalisation. For CUB-200-2011, the images are cropped using ground-truth bounding box annotations and resized. For cross-domain image classification we downsample the input images to avoid the memory overhead. ",
+        "bbox": [
+            174,
+            276,
+            825,
+            333
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/a6187806e43c652393583412b66f7d3584fc55d75e4751c887b97ef58e8f8521.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Size (total/train/test/extra)</td><td>Number of classes /Type</td><td>Resolution</td><td>Tasks</td></tr><tr><td>CIFAR-10 (Krizhevsky&amp; Hinton,2009)</td><td>60,000 /50,000 /10,000 ／-</td><td>10 ／natural images</td><td>32x32</td><td>C,C-c,S</td></tr><tr><td>CIFAR-10O (Krizhevsky &amp; Hinton,2009)</td><td>60,000 /50,000 /10,000 ／-</td><td>100 ／natural images</td><td>32x32</td><td>C,C-c,S</td></tr><tr><td>SVHN (Netzer et al.,2011)</td><td>-/73,257 /26.032/531,131</td><td>10 /digits</td><td>32x32</td><td>C</td></tr><tr><td>CUB-200-2011(Wah et al., 2011)</td><td>-/5,994/5,794/-</td><td>200 /bird images</td><td>80x80</td><td>C</td></tr><tr><td>STL (Coates et al.,2010)</td><td>-/5,000/8,000/-</td><td>10/ImageNet images</td><td>96x96</td><td>C-c</td></tr><tr><td>Caltech-101 (Fei-Fei et al.,2006)</td><td>8677/-/-/-</td><td>101 /natural images</td><td>~300x200</td><td>C-c</td></tr><tr><td>Caltech-256 (Griffin et al.,2007)</td><td>29,780/-/-/-</td><td>256 /natural images</td><td>~300x200</td><td>C-c</td></tr><tr><td>Event-8 (Li&amp; Fei-Fei,2007)</td><td>1574/-/-/-</td><td>8 /in/out door sports</td><td>&gt;600x600</td><td>C-c</td></tr><tr><td>Action-40 (Yao et al., 2011)</td><td>9532/-/-/-</td><td>40 /natural images</td><td>~400x300</td><td>C-c</td></tr><tr><td>Scene-67(Quattoni &amp; Torralba,2009)</td><td>15613/-/-/-</td><td>67 /indoor scenes</td><td>~500x300</td><td>C-c</td></tr><tr><td>Object Discovery (Rubinstein et al., 2013)</td><td>300/-/300/-</td><td>3/synthetic and natural images</td><td>~340x240</td><td>C-c,S</td></tr></table>",
+        "bbox": [
+            173,
+            344,
+            836,
+            481
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Summary of datasets used for experiments across different tasks (C: classification, C-c: classification cross-domain, S: segmentation).The natural images span from those of objects in plain background to cluttered indoor and outdoor scenes. The objects vary from simple digits to humans involved in complex activities. ",
+        "bbox": [
+            173,
+            498,
+            825,
+            555
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.2 NETWORK ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            578,
+            411,
+            592
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Progressive attention networks: We experiment with the progressive attention mechanism proposed by Seo et al. (2016) as part of our 2-level attention-based VGG models. The attention at the lower level (layer-10) is implemented using a 2D map of compatibility scores, obtained using the parameterised compatibility function discussed in $\\ S 3 . 2$ . Note that at this level, the compatibility scores are not jointly normalised using the softmax operation, but are normalised independently using the pointwise sigmoid function. These scores, at each spatial location, are used to weigh the corresponding local features before the feature vectors are fed to the next network layer. This is the filtering operation at the core of the progressive attention scheme proposed by Seo et al. (2016). For the final level, attention is implemented in the same way as in VGG-att2-concat-pc. The compatibility scores are normalised using a softmax operation and the local features, added in proportion to the normalised attention scores, are trained for image classification. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            756
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We implement and evaluate the above-discussed progressive attention approach as well as the proposed attention mechanism with the VGG architecture using the codebase provided here: https://github.com/szagoruyko/cifar.torch. The code for CIFAR dataset normalisation is included in the repository. ",
+        "bbox": [
+            176,
+            763,
+            825,
+            819
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Attention in ResNet: For the ResNet architecture, we make the attention-related modifications to the network specification provided here: https://github.com/szagoruyko/wide-residualnetworks/tree/fp16/models. The baseline ResNet implementation consists of 4 distinct levels that project the RGB input onto a 256-dimensional space through 16-, 64-, and 128-dimensional embedding spaces respectively. Each level excepting the first, which contains 2 convolutional layers separated by a non-linearity, contains $n$ -residual blocks. Each residual block in turn contains a maximum of 3 convolutional layers interleaved with non-linearities. This yields a network definition of ",
+        "bbox": [
+            174,
+            825,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "$9 n + 2$ parameterised layers (He et al., 2015). We work with an $n$ of 18 for a 164-layered network.   \nBatch normalization is incorporated in a manner similar to other contemporary networks. ",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We replace the spatial average pooling layer after the final and $4 ^ { t h }$ level by convolutional and maxpooling operations which gives us our global feature vector $\\textbf {  { g } }$ . We refer to the network implementing attention at the output of the last level as RN-att and with attention at the output of last two levels as RN-att2. Following the results obtained on the VGG network, we train the attention units in the concat-pc framework. ",
+        "bbox": [
+            174,
+            138,
+            823,
+            208
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.3 TRAINING ROUTINES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            232,
+            362,
+            246
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "VGG networks for CIFAR-10, CIFAR-100 and SVHN are trained from scratch. We use a stochastic gradient descent (SGD) optimiser with a batch size of 128, learning rate decay of $1 0 ^ { - 7 }$ , weight decay of $5 \\times 1 0 ^ { - 4 }$ , and momentum of 0.9. The initial learning rate for CIFAR experiments is 1 and for SVHN is 0.1. The learning rate is scaled by 0.5 every 25 epochs and we train over 300 epochs for convergence. For CUB, since the training data is limited, we initialise the model with the weights learned for CIFAR-100. We use the transfer-learning training schedule inspired by Redmon et al. (2015). Thus the training starts at a learning rate of 0.1 for first 30 epochs, is multiplied by 2 twice over the next 60 epochs, and then scaled by 0.5 every 30 epochs for the next 200 epochs. ",
+        "bbox": [
+            174,
+            261,
+            825,
+            372
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For ResNet, the networks are trained using an SGD optimizer with a batch size of 64, initial learning rate of 0.1, weight decay of $5 \\times 1 0 ^ { - 4 }$ , and a momentum of 0.9. The learning rate is multiplied by 0.2 after 60, 120 and 160 epochs. The network is trained for 200 epochs until convergence. We train the models for CIFAR-10 and CIFAR-100 from scratch. ",
+        "bbox": [
+            174,
+            380,
+            823,
+            435
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "All models are implemented in Torch and trained with an NVIDIA Titan-X GPU. Training takes around one to two days depending on the model and datasets. ",
+        "bbox": [
+            173,
+            443,
+            823,
+            469
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.4 TASK-SPECIFIC PROCESSING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            494,
+            415,
+            508
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We generate the adversarial images using the fast gradient sign method of Goodfellow et al. (2014) and observe the network fooling behaviour at increasing $L _ { \\infty }$ norms of the perturbations. ",
+        "bbox": [
+            176,
+            522,
+            821,
+            551
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For cross-domain classification, we extract features at the input of the final fully connected layer of each model, use these to train a linear SVM with $C \\ = \\ 1$ and report the results of a 5- fold cross validation, similar to the setup used by Zhou et al. (2016). At no point do we finetune the networks on the target datasets. We perform ZCA whitening on all the evaluation datasets using the pre-processing Python scripts specified in the following for whitening CIFAR datasets: https://github.com/szagoruyko/wide-residual-networks/tree/fp16. ",
+        "bbox": [
+            174,
+            558,
+            823,
+            641
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For weakly supervised segmentation, the evaluation datasets are preprocessed for colour normalisation using the same scheme as adopted for normalising the training datasets of the respective models. For the proposed attention mechanism, we combine the attention maps from the last 2 levels using element-wise multiplication, take the square root of the result to re-interpret it as a probability distribution (in the limit of the two probabilistic attention distributions approaching each other), rescale the values in the resultant map to a range of [0, 1] and binarise the map using the Otsu binarization threshold. For the progressive attention mechanism of Seo et al. (2016), we simply multiply the attention maps from the two different levels without taking their square root, given that these attention maps are not complementary but sequential maps used to fully develop the final attention distribution. The rest of the operations of magnitude rescaling and binarisation are commonly applied to all the final attention maps, including those obtained using GAP (Zhou et al., 2016). ",
+        "bbox": [
+            174,
+            648,
+            825,
+            801
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.5 QUERY-DRIVEN ATTENTION PATTERNS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            825,
+            485,
+            839
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In our framework, the global feature vector is used as a query for estimating attention on the local image regions. Thus, by changing the global feature vector, one could expect to affect the attention distribution estimated over the local regions in a predictable manner. The extent to which the two different compatibility functions, the parameterised and the dot-product-based compatibility functions, allow for such external control over the estimated attention patterns may be varied. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For the purpose of the analysis, we consider two different network architectures. The first is the (VGG-att2)-concat-dp (DP) model from Table 1 which uses a dot-product-based compatibility function. The other is the (VGG-att3)-concat-pc (PC) model which makes use of the parameterised compatibility function. In terms of the dataset, we make use of the extra cosegmentation image set available with the Object Discovery dataset package. We select a single image centrally focused on an instance of a given object category and call this the query image. We then gather a few distinct images that contain objects of the same category but in a more cluttered environment with pose and intra-class variations. We call these the target images. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In order to visualise the role of the global feature vector in driving the estimated attention patterns, we perform two rounds of experiments. In the first round, we obtain both the global and local image feature vectors from a given target image, shown in column 2 of every row of Figure 10. The processing follows the standard protocol and the resulting attention patterns at layer 10 for the two architectures can be seen in columns 3 and 6 of the same figure. In the second round, we obtain the local feature vectors from the target image but the global feature vector is obtained by processing the query image specific to the category being considered, shown in column 1. The new attention patterns are displayed in columns 4 and 7 respectively. The changes in the attention values at different spatial locations as a proportion of the original attention pattern values are shown in columns 5 and 8 respectively. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            361
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Notably, for the dot-product-based attention mechanism, the global vector plays a prominent role in guiding attention. This is visible in the increase in the attention magnitudes at the spatial locations near or related to the query image object. On the other hand, for the attention mechanism that makes use of the parameterised compatibility function, the global feature vector seems to be redundant. Any change in the global feature vector does not transfer to the resulting attention map. In fact, numerical observations show that the magnitudes of the global features are often a couple of orders of magnitude smaller than those of the corresponding local features. Thus, a change in the global feature vector has little to no impact on the predicted attention scores. Yet, the attention maps themselves are able to consistently highlight object-relevant image regions. Thus, it appears that in the case of parameterised compatibility based attention, the object-centric high-order features are learned as part of the weight vector $\\textbf { \\em u }$ . These features are adapted to the training dataset and are able to generalise to new images inasmuch as the object categories at test time are similar to those seen during training. ",
+        "bbox": [
+            174,
+            368,
+            825,
+            549
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/2b2611a73097ff90aeaea799b4af3d80c3e4a758d3e9cda01343c223fb949b96.jpg",
+        "image_caption": [
+            "Figure 10: Visual analysis of how a global feature vector obtained from a query image affects the attention patterns on the local image regions of another distinct target image. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            128,
+            833,
+            862
+        ],
+        "page_idx": 13
+    }
+]

parse/train/OAMrSPRRxJx/OAMrSPRRxJx.md

@@ -0,0 +1,433 @@
+# Deep Policy Dynamic Programming for Vehicle Routing Problems
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Routing problems are a class of combinatorial problems with many practical   
+2 applications. Recently, end-to-end deep learning methods have been proposed   
+3 to learn approximate solution heuristics for such problems. In contrast, classical   
+4 dynamic programming (DP) algorithms guarantee optimal solutions, but scale   
+5 badly with the problem size. We propose Deep Policy Dynamic Programming   
+6 (DPDP), which aims to combine the strengths of learned neural heuristics with   
+7 those of DP algorithms. DPDP prioritizes and restricts the DP state space using   
+8 a policy derived from a deep neural network, which is trained to predict edges   
+9 from example solutions. We evaluate our framework on the travelling salesman   
+10 problem (TSP), the vehicle routing problem (VRP) and TSP with time windows   
+11 (TSPTW) and show that the neural policy improves the performance of (restricted)   
+12 DP algorithms, making them competitive to strong alternatives such as LKH, while   
+13 also outperforming most other ‘neural approaches’ for solving TSPs, VRPs and   
+14 TSPTWs with 100 nodes.
+
+# 15 1 Introduction
+
+16 Dynamic programming (DP) is a powerful framework for solving optimization problems by solving   
+17 smaller subproblems through the principle of optimality [3]. Famous examples are Dijkstra’s   
+18 algorithm [14] for the shortest route between two locations, and the classic Held-Karp algorithm for   
+19 the travelling salesman problem (TSP) [23, 4]. Despite their long history, dynamic programming   
+20 algorithms for vehicle routing problems (VRPs) have seen limited use in practice, primarily due to   
+21 their bad scaling performance. More recently, a line of research has attempted the use of machine   
+22 learning (especially deep learning) to automatically learn heuristics for solving routing problems   
+23 [57, 5, 41, 29, 7]. While the results are promising, most learned heuristics are not (yet) competitive   
+24 to ‘traditional’ algorithms such as LKH [24] and lack (asymptotic) guarantees on their performance.   
+25 In this paper, we propose Deep Policy Dynamic Programming (DPDP) as a framework for solving   
+26 vehicle routing problems. The key of DPDP is to combine the strengths of deep learning and DP,   
+27 by restricting the DP state space (the search space) using a policy derived from a neural network.   
+28 In Figure 1 it can be seen how the neural network indicates promising parts of the search space   
+29 (through a heatmap over the edges of the graph), which is then used by the DP algorithm to find a   
+30 good solution. DPDP is more powerful than some related ideas [62, 52, 61, 6, 34] as it combines   
+31 supervised training of a large neural network with just a single model evaluation at test time, to enable   
+32 running a large scale guided search using DP. The DP framework is flexible as it can model a variety   
+33 of realistic routing problems with difficult practical constraints [20]. We illustrate this by testing   
+34 DPDP on the TSP, the capacitated VRP and the TSP with (hard) time window constraints (TSPTW).   
+35 In more detail, the starting point of our proposed approach is a restricted dynamic programming   
+36 algorithm [20]. Such an algorithm heuristically reduces the search space by retaining only the $B$ most   
+37 promising solutions per iteration. The selection process is very important as it defines the part of the   
+38 DP state space considered and, thus, the quality of the solution found (see Fig. 2). Instead of manually   
+39 defining a selection criterion, DPDP defines it using a (sparse) heatmap of promising route segments   
+40 obtained by pre-processing the problem instance using a (deep) graph neural network (GNN) [26].   
+41 This approach is reminiscent of neural branching policies for branch-and-bound algorithms [19, 40].   
+42 In this work, we thus aim for a ‘neural boost’ of DP algorithms, by using a graph neural network   
+43 for scoring partial solutions. Prior work on ‘neural’ vehicle routing has focused on auto-regressive   
+44 models [57, 5, 13, 29], but they have high computational cost when combined with (any form of)   
+45 search, as the model needs to be evaluated for each partial solution considered. Instead, we use (for   
+46 TSP) and adapt (for VRP and TSPTW) a model to predict a heatmap indicating promising edges [26],   
+47 and define the score of a partial solution as the ‘heat’ of the edges it contains (plus an estimate of the   
+48 ‘heat-to-go’ or potential of the solution). As the neural network only needs to be evaluated once for   
+49 each instance, this enables a much larger search (defined by $B$ ), making a good trade-off between   
+50 quality and computational cost. Additionally, we can apply a threshold to the heatmap to define a   
+51 sparse graph on which to run the DP algorithm, reducing the runtime by eliminating many solutions.   
+52 Figure 2 illustrates the overall DPDP algorithm. In Section 4, we show that DPDP significantly   
+53 improves over ‘classic’ restricted DP algorithms (with the same $B$ ). Additionally, we show that   
+54 DPDP outperformes most other ‘neural’ approaches for TSP, VRP and TSPTW and is competitive   
+55 with the highly-optimized LKH solver [24] for VRP, while achieving similar results much faster for   
+56 TSP and TSPTW. For TSPTW, DPDP also outperforms the best open-source solver we could find   
+57 [10], illustrating the power of DPDP to handle difficult hard constraints (time windows).   
+59 DP has a long history as an exact solution method for routing problems [31, 50], e.g. for the TSP   
+60 with time windows [15] and precedence constraints [39], but typically limited to small problems only,   
+61 due to the curse of dimensionality. Restricted DP (with heuristic policies) has been used to address,   
+62 e.g., the time dependent TSP [37], and has been generalized into a flexible framework for VRPs with   
+63 different types of practical constraints [20]. DP approaches have also been shown to be useful in   
+64 settings with difficult practical issues such as time-dependent travel times and driving regulations [28]   
+65 or stochastic demands [42]. For a thorough investigation of modelling choices of DP for routing (and   
+66 scheduling), see [53]. For sparse graphs, alternative, but less flexible, formulations can be used [8].   
+67 Despite the flexibility, constructive DP methods have not gained much popularity compared to   
+68 heuristic search approaches such as Ruin and Recreate [47], Adaptive Large Neighborhood Search   
+69 [46], LKH [24] or FILO [1]. While highly effective, these methods are limited in their flexibility as   
+70 special operators need to be engineered for different types of problems. While restricted DP was   
+71 shown to have superior performance on realistic VRPs with many constraints [20], the performance   
+72 gap of around $10 \%$ for standard (benchmark) VRPs (with time windows) is too large to popularize   
+73 the restricted dynamic programming approach. We argue that the missing ingredient for restricted   
+74 dynamic programming is the availability of a strong but computationally cheap policy for selecting   
+75 which solutions should be considered, which is the motivation behind DPDP.   
+76 In the machine learning community, recent advances have significantly improved deep neural networks   
+77 (DNNs) to perform tasks such as image classification and machine translation [32]. After the first   
+78 deep learning model was trained (using example solutions) to construct TSP tours [57], many   
+79 improvements have been proposed, e.g. different training strategies such as reinforcement learning   
+80 (RL) [5, 27, 12, 30] and model architectures, which enabled the same idea to be used for other   
+81 routing problems [41, 29, 13, 45, 16, 60]. Most constructive neural methods are auto-regressive,   
+82 evaluating the model many times to predict one node at the time, but other works have considered   
+83 predicting a ‘heatmap’ of promising edges at once [43, 26, 17], which allows a tour to be constructed   
+84 (using sampling or beam search) without further evaluating the model. An alternative direction is   
+85 ‘learning to search’, where a neural network is used to guide a search procedure such as local search   
+86 [7, 35, 18, 59, 25]. Some works have attempted scaling to larger instances beyond 100 nodes, which   
+87 remains challenging [36, 17]. The combination of machine learning with DP has been proposed in   
+88 limited settings [62, 52, 61]. Most related to our approach, a DP algorithm for TSPTW, guided by an   
+89 RL agent, was implemented using an existing solver [6] and a neural network predicting edges has   
+90 been combined with tree search [34] and local search for maximum independent set (MIS). For a   
+91 wider view on machine learning for routing problems and combinatorial optimization, see [38, 54].
+
+![](images/1c606b2da8db1f29e1a67ef5708a054b86e14e8c3a6d39cebb45c66debd49d66.jpg)  
+Figure 1: Heatmap predictions (red) and solutions (colored) by DPDP (VRP depot edges omitted).
+
+![](images/a9614c90b20b1c7af3c817ba41c3c6adfe96c5f48f6ed7ba1d72eb36ff304481.jpg)  
+Figure 2: Deep Policy Dynamic Programming for the TSP. A GNN creates a (sparse) heatmap indicating promising edges, after which a tour is constructed using forward dynamic programming. In each step, at most $B$ solutions are expanded according to the heatmap policy, restricting the size of the search space. Partial solutions are dominated by shorter (lower cost) solutions with the same DP state: the same nodes visited (marked grey) and current node (indicated by dashed rectangles).
+
+# 92 3 Deep Policy Dynamic Programming
+
+93 DPDP uses an existing graph neural network [26] (which we modify for VRP and TSPTW) to predict   
+94 a heatmap of promising edges, which is used to derive the policy for scoring partial solutions in   
+95 the DP algorithm. The DP algorithm starts with a beam of a single initial (empty) solution. It then   
+96 proceeds by iterating the following steps: (1) all solutions on the beam are expanded, (2) dominated   
+97 solutions are removed for each $D P$ state, (3) the $B$ best solutions according to the scoring policy   
+98 define the beam for the next iteration. These steps are illustrated in Fig. 2. The objective function is   
+99 used to select the best solution from the final beam. The resulting algorithm is a beam search over the   
+100 DP state space (which is not a ‘standard beam search’ over the solution space!) and we call $B$ the   
+101 beam size. DPDP is asymptotically optimal as using $B = n \cdot 2 ^ { n }$ for a TSP with $n$ nodes guarantees   
+102 optimal results, but choosing smaller $B$ allows to trade performance for computational cost.   
+103 DPDP is a generic framework that can be applied to different problems, by defining the following   
+104 ingredients: (1) the state variables to track while constructing solutions, (2) the initial solution,   
+105 (3) feasible actions to expand solutions, (4) rules to define dominated solutions and (5) a scoring   
+106 policy for selecting the $B$ solutions to keep. A solution is always (uniquely) defined as a sequence of   
+107 actions, which allows the DP algorithm to construct the final solution by backtracking. In the next   
+108 sections, we define these ingredients for the TSP, VRP and TSPTW.   
+10 We implement DPDP for Euclidean TSPs with $n$ nodes on a (sparse) graph, where the cost for edge   
+11 $( i , j )$ is given by $c _ { i j }$ , the Euclidean distance between the coordinates of nodes $i$ and $j$ .   
+112 For each partial solution, defined by a sequence of actions $^ { a }$ , the state variables are $\displaystyle \cos t ( \pmb { a } )$ , the   
+113 total cost (distance), current $( a )$ , the current node, and visited $( a )$ , the set of visited nodes (including   
+114 the start node). Without loss of generality, we let 0 be the start node, so we initialize the beam at step   
+115 $t = 0$ with the empty initial solution with $\cos ( { \pmb a } ) = 0$ , current $( { \pmb a } ) = 0$ and $\mathrm { v i s i t e d } ( a ) = \{ 0 \}$ . At   
+116 step $t$ , the action $\bar { a } _ { t } \in \{ 0 , . . . , n - 1 \}$ indicates the next node to visit, and is a feasible action for a   
+117 partial solution $\pmb { a } = ( a _ { 0 } , . . . , a _ { t - 1 } )$ if $( a _ { t - 1 } , a _ { t } )$ is an edge in the graph and $a _ { t } \not \in { \mathrm { v i s i t e d } } ( a )$ , or, when   
+118 all are visited, if $a _ { t } = 0$ to return to the start node. When expanding the solution to $\pmb { a } ^ { \prime } = ( a _ { 0 } , . . . , a _ { t } )$ ,   
+119 we can compute the state variables incrementally as:
+
+$$
+\begin{array} { r } { \mathrm { c o s t } ( a ^ { \prime } ) = \mathrm { c o s t } ( a ) + { c } _ { \mathrm { c u r r e n t } ( a ) , a _ { t } } , \quad \mathrm { c u r r e n t } ( a ^ { \prime } ) = a _ { t } , \quad \mathrm { v i s i t e d } ( a ^ { \prime } ) = \mathrm { v i s i t e d } ( a ) \cup \{ a _ { t } \} . } \end{array}
+$$
+
+120 A (partial) solution $\textbf { \em a }$ is a dominated solution if there exists a (dominating) solution $\mathbf { \delta } \mathbf { a } ^ { * }$ such   
+121 that visited $( { \pmb a } ^ { * } ) = \mathrm { v i s i t e d } ( { \pmb a } )$ , current $( a ^ { * } ) = \operatorname { c u r r e n t } ( a )$ and $\mathrm { c o s t } ( { \pmb a } ^ { * } ) < \mathrm { c o s t } ( { \pmb a } )$ . The tuple   
+122 (visited $( a )$ , current $( a )$ ) we refer to as the $D P$ state, so removing all dominated partial solutions,   
+123 we keep exactly one minimum-cost solution for each unique DP state1. Since a solution can only   
+124 dominate other solutions with the same set of visited nodes, we only need to remove dominated   
+125 solutions from sets of solutions with the same number of actions. Therefore, we can efficiently   
+126 execute the DP algorithm in iterations, where at step $t$ all solutions have (after $t$ actions) $t + 1$ visited   
+127 nodes (including the start node), keeping the memory need at $O ( B )$ states (with $B$ the beam size).   
+128 We define the scoring policy using a pretrained model [26], which takes as input node coordinates   
+129 and edge distances to predict a raw ‘heatmap’ value $\hat { h } _ { i j } \in ( 0 , 1 )$ for each edge $( i , j )$ . The model was   
+130 trained to predict optimal solutions, so $\hat { h } _ { i j }$ can be seen as the probability that edge $( i , j )$ is in the   
+131 optimal tour. We force the heatmap to be symmetric thus we define $h _ { i j } = \operatorname* { m a x } \{ \hat { h } _ { i j } , \hat { h } _ { j i } \}$ . The policy   
+132 is defined using the heatmap values, in such a way to select the (partial) solutions with the largest   
+133 total heat, while also taking into account the (heat) potential for the unvisited nodes. The policy thus   
+134 selects the $B$ solutions which have the highest score, defined as $\operatorname { s c o r e } ( { a } ) = \operatorname { h e a t } ( { a } ) + \operatorname { p o t e n t i a l } ( { a } )$ ,   
+135 with $\begin{array} { r } { \mathrm { h e a t } ( { \pmb a } ) = \sum _ { i = 1 } ^ { t - 1 } h _ { a _ { i - 1 } , a _ { i } } } \end{array}$ , i.e. the sum of the heat of the edges, which can be computed   
+136 incrementally when expanding a solution. The potential is added as an estimate of the ‘heat-to  
+137 go’ (similar to the heuristic in $A ^ { * }$ search) for the remaining nodes, and avoids the ‘greedy pitfall’   
+138 of selecting the best edges while skipping over nearby nodes, which would prevent good edges   
+139 from being used later. It is defined as potentia $\begin{array} { r } { \mathsf { l } ( \pmb { a } ) = \bar { \mathrm { p o t e n t i a l } } _ { 0 } ( \pmb { a } ) + \sum _ { i \notin \mathrm { v i s i t e d } ( \pmb { a } ) } } \end{array}$ potential ${ \bf \nabla } _ { \mathrm { { i } } } ( { \bf a } )$   
+140 with potentiali(a) = wi Pj6∈visited(a) , where $w _ { i }$ is the node potential weight given by   
+141 $\begin{array} { r } { w _ { i } = ( \operatorname* { m a x } _ { j } h _ { j i } ) \cdot ( 1 - 0 . 1 ( \frac { c _ { i 0 } } { \operatorname* { m a x } _ { j } c _ { j 0 } } - \overline { { 0 . 5 } } ) ) } \end{array}$ . By normalizing the heatmap values for incoming   
+142 edges, the (remaining) potential for node $i$ is initially equal to $w _ { i }$ but decreases as good edges   
+143 become infeasible due to neighbours being visited. The node potential weight $w _ { i }$ is equal to the   
+144 maximum incoming edge heatmap value (an upper bound to the heat contributed by node $i$ ), which   
+145 gets multiplied by a factor 0.95 to 1.05 to give a higher weight to nodes closer to the start node, which   
+146 we found helps to encourage the algorithm to keep edges that enable to return to the start node. The   
+147 overall heat $^ +$ potential function identifies promising partial solutions and is computationally cheap.
+
+# 3.2 Vehicle Routing Problem
+
+For the VRP, we add a special depot node to the graph, indicated by DEP. Each node $i$ has a demand $d _ { i }$ , and the goal is to find multiple routes, which have a limited capacity denoted by CAPACITY.
+
+Additionally to the TSP state variables $\displaystyle \cos t ( a )$ , $\mathrm { c u r r e n t } ( a )$ and visited $( a )$ , we keep track of capacity $( a )$ , which is the remaining capacity in the current route/vehicle. A solution starts at the depot, so we initialize the beam at step $t = 0$ with the empty initial solution with $\mathrm { c o s t } ( \pmb { a } ) = 0$ , ${ \mathrm { c u r r e n t } } ( { \pmb a } ) = { \mathrm { D E P } } , { \mathrm { v i s i t e d } } ( { \pmb a } ) = \emptyset$ and capacity $( a ) =$ CAPACITY. For the VRP, we do not consider visiting the depot as a separate action. Instead, we define $2 n$ actions, where $a _ { t } \in \{ 0 , . . . , 2 n - 1 \}$ . The actions $0 , . . . , n - 1$ indicate a direct move from the current node to node $a _ { t }$ , whereas the actions
+
+157 $n , . . . , 2 n - 1$ indicate a move to node $a _ { t } - n$ via the depot. Feasible actions are those that move   
+158 to unvisited nodes via edges in the graph and obey the following constraints. For the first action   
+159 $a _ { 0 }$ there is no choice and we constrain (for convenience of implementation) $a _ { 0 } \in \{ n , . . . , 2 n - 1 \}$ .   
+160 A direct move $( a _ { t } < n )$ is only feasible if $d _ { a _ { t } } \leq \mathrm { c a p a c i t y } ( { \pmb a } )$ and updates the state similar to TSP   
+161 but reduces remaining capacity by $d _ { a _ { t } }$ . A move via the depot is always feasible (respecting the   
+162 163 graph edges and assuming demand, but incurs the ‘via $d _ { i } \leq \mathrm { C A P A C I T Y } \forall i )$ $c _ { i j } ^ { \tt D E P } = c _ { i , \tt D E P } + c _ { \tt D E P , , j }$ e vehicle CAPACITY before subtracting. When all nodes are visited, we allow a   
+164 special action to return to the depot. This somewhat unusual way of representing a CVRP solution   
+165 has desirable properties similar to the TSP formulation: at step $t$ we have exactly $t$ nodes visited, and   
+166 we can run the DP in iterations, removing dominated solutions at each step $t$ .   
+167 For VRP, a partial solution $^ { a }$ is a dominated solution dominated by $\mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \overline { { \delta \delta } } \mathbf { \delta } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm \mathrm { ~ } \mathrm { ~ } \mathrm \delta \mathrm { ~ } \mathrm { ~ } \delta \mathrm \mathrm { ~ } \delta \mathrm \mathrm { ~ } \delta \mathrm \mathrm { ~ } \delta \mathrm \mathrm \delta \mathrm \mathrm { ~ ~ } \delta \delta \mathrm \delta \mathrm \mathrm \delta \mathrm \delta \mathrm \mathrm \delta \mathrm \delta \delta \mathrm \delta \delta \mathrm \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta $ if v $\operatorname { i s i t e d } ( { \pmb a } ^ { * } ) = \operatorname { v i s i t e d } ( { \pmb a } )$   
+168 and current $( a ^ { * } ) = \mathrm { c u r r e n t } ( a )$ (i.e. $\mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } ( \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } ) \delta \mathbf { \delta } ( \delta \mathbf { \delta } ) \delta \mathbf { \delta } ( \delta \mathbf { \delta } ) \delta \delta \mathbf { \delta \delta } ( \delta \mathbf { \delta } ) \delta \delta ( \delta \mathbf { \delta } \mathrm { \delta \delta } ) \delta \delta \delta ( \delta \delta \mathbf { \delta } \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta$ corresponds to the same DP state) and $\mathrm { c o s t } ( { \pmb a } ^ { * } ) \leq \mathrm { c o s t } ( { \pmb a } )$   
+169 and capacity $( a ^ { * } ) \geq \mathrm { c a p a c i t y } ( a )$ , with at least one of the two inequalities being strict. This means   
+170 that for each DP state, given by the set of visited nodes and the current node, we do not only keep   
+171 the (single) solution with lowest cost (as in the TSP algorithm), but keep the complete set of pareto  
+172 efficient solutions in terms of cost and remaining vehicle capacity. This is because a higher cost   
+173 partial solution may still be preferred if it has more remaining vehicle capacity, and vice versa.   
+174 For the VRP scoring policy, we modify the model [26] to include the depot node and demands. The   
+175 special depot node gets a separate learned initial embedding parameter, and we add additional edge   
+176 types for connections to the depot, to mark the depot as being special. Additionally, each node gets   
+177 an extra input (next to its coordinates) corresponding to $d _ { i }$ /CAPACITY (where we set $d _ { \tt D E P } = 0 _ { , }$ ).   
+178 Apart from this, the model remains exactly the same2. The model is trained on example solutions   
+179 from LKH [24] (see Section 4.2), which are not optimal, but still provide a useful training signal.   
+180 Compared to TSP, the definition of the heat is slightly changed to accommodate for the ‘via-depot   
+181 actions’ and is best defined incrementally using the ‘via-depot heat’ $h _ { i j } ^ { \tt D E P } = h _ { i , \tt D E P } \cdot h _ { \tt D E P , \it j } \cdot \bar { 0 } . 1 .$   
+182 where multiplication is used to keep heat values interpretable as probabilities and in the range $( 0 , 1 )$ .   
+183 The additional penalty factor of 0.1 for visiting the depot encourages the algorithm to minimize the   
+184 number of vehicles/routes. The initial heat is 0 and when expanding a solution $\textbf { \em a }$ to $\mathbf { { a } ^ { \prime } }$ using action   
+185 $a _ { t }$ , the heat is incremented with either $h _ { \mathrm { c u r r e n t } ( \mathbf { a } ) , a _ { t } }$ (if $a _ { t } < n )$ or hDEPcurrent(a),at−n (if at ≥ n). The   
+186 potential is defined similarly to TSP, replacing the start node 0 by DEP.
+
+# 3.3 Travelling Salesman Problem with Time Windows
+
+188 For the TSPTW, we also have a special depot $/$ start node 0, and each node $i$ has a time window   
+189 defined by $( l _ { i } , u _ { i } )$ in which the node should be visited, assuming travel time is equal to cost/distance.   
+190 It is allowed to wait if arrival at a node is before $l _ { i }$ , but arrival cannot be after $u _ { i }$ (i.e. the constraint is   
+191 hard). We consider the objective to be minimizing total cost, but minimizing total time (or makespan)   
+192 only requires training on different example solutions. Due to the hard constraints, TSPTW is typically   
+193 considered more challenging to solve than plain TSP, for which every solution is feasible.
+
+The state variables and initial solution are equal to TSP except that we add $\mathrm { t i m e } ( a )$ which is initially $0 ( = l _ { 0 } )$ . Feasible actions $a _ { t } \in \{ 0 , . . . , n - 1 \}$ are those that move to unvisited nodes via edges in the graph such that the arrival time is no later than $u _ { a _ { t } }$ and do not directly eliminate the possibility to visit other nodes in time3. Expanding a solution $\textbf { \em a }$ to $\mathbf { { \boldsymbol { a } } } ^ { \prime }$ using action $a _ { t }$ updates the time as $\mathrm { t i m e } ( { \pmb a } ^ { \prime } ) = \mathrm { m a x } \{ \mathrm { t i m e } ( { \pmb a } ) + c _ { \mathrm { c u r r e n t } ( { \pmb a } ) , { \pmb a } _ { t } } , \bar { l } _ { { \pmb a } _ { t } } \}$ .
+
+For each DP state, we keep all efficient solutions in terms of cost and time, so a partial solution $\textbf { \em a }$ is a dominated solution dominated by $\mathbf { \delta } \mathbf { \mathbf { \vec { a } } } ^ { * }$ if $\mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \mathbf { \delta } \overline { { \delta \delta } } \mathbf { \delta } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm { ~ } \mathrm \mathrm { ~ } \mathrm { ~ } \mathrm \delta \mathrm { ~ } \mathrm { ~ } \delta \mathrm \mathrm { ~ } \delta \mathrm \mathrm { ~ } \delta \mathrm \mathrm { ~ } \delta \mathrm \mathrm \delta \mathrm \mathrm { ~ ~ } \delta \delta \mathrm \delta \mathrm \mathrm \delta \mathrm \delta \mathrm \mathrm \delta \mathrm \delta \delta \mathrm \delta \delta \mathrm \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta \delta $ has the same DP state $( \mathrm { v i s i t e d } ( { \pmb a } ^ { * } ) = \mathrm { v i s i t e d } ( { \pmb a } )$ and current $( { \pmb a } ^ { * } ) = \mathrm { c u r r e n t } ( { \pmb a } ) )$ and is strictly better in terms of cost and time, i.e. $\mathrm { c o s t } ( { \pmb a } ^ { * } ) \leq \mathrm { c o s t } ( { \pmb a } )$ and $\mathrm { t i m e } ( a ^ { * } ) \leq \mathrm { t i m e } ( a )$ , with at least one of the two inequalities being strict.
+
+The model [26] for the scoring policy is adapted to include the time windows $( l _ { i } , u _ { i } )$ as node features (in the same unit as coordinates and costs), and we use a special embedding for the depot similar to VRP. Due to the time dimension, a TSPTW solution is directed, and edge $( i , j )$ may be good whereas $( j , i )$ may be not, so we adapt the model to enable predictions $h _ { i j } \neq h _ { j i }$ (see details in Appendix B). We generated example training solutions using (heuristic) DP with a large beam size, which was faster than using LKH. Given the heat predictions, the score (heat $^ +$ potential) is exactly as for TSP.
+
+As described, the DP algorithm can take into account a sparse graph to define feasible expansions. As our problems are defined on sets of nodes rather than graphs, the use of a sparse graph is an artificial design choice, which allows to significantly reduce the runtime but may sacrifice the possibility to find good or optimal tours. We propose two different strategies for defining the sparse graph on which to run the DP: thresholding the heatmap values $h _ { i j }$ and using the K-nearest neighbour (KNN) graph. By default, we use a (low) heatmap threshold of $\mathrm { { 1 0 ^ { - 5 } } }$ , which rules out most of the edges as the model confidently predicts (close to) 0 for most edges. This is a secondary way to leverage the neural network (independent of the scoring policy), which can be seen as a form of learned problem reduction [49]. For symmetric problems (TSP and VRP), we add KNN edges in both directions. For the VRP, we additionally connect each node to the depot (and vice versa) to ensure feasibility.
+
+# 20 3.5 Implementation $\pmb { \& }$ hyperparameters
+
+We implement DPDP using PyTorch [44] to leverage batched computation on the GPU. For details, see Appendix A. Our code is publicly available. 4 DPDP has very few hyperparameters, but the heatmap threshold of $1 0 ^ { - 5 }$ and details like the functional form of e.g. the scoring policy are ‘educated guesses’ or manually tuned on a few validation instances and can likely be improved. The runtime is influenced by implementation choices which were manually selected using a few validation instances.
+
+# 4 Experiments
+
+# 4.1 Travelling Salesman Problem
+
+In Table 1 we report our main results for DPDP with beam sizes of 10K (10 thousand) and 100K, for the TSP with 100 nodes on a commonly used test set [29]. We report results using Concorde [2], LKH [24] and Gurobi [22], as well as recent results of the strongest methods using neural networks (‘neural approaches’) from literature. Running times for solving 10000 instances after training should be taken as rough indications as some are on different machines, typically with 1 GPU or a many-core CPU (8 - 32). The costs indicated with \* are not directly comparable due to slight dataset differences [17]. Times for generating heatmaps (if applicable) is reported separately (as the first term) from the running time for MCTS [17] or DP. DPDP achieves close to optimal results, strictly outperforming the neural baselines achieving better results in less time (except POMO [30], see Section 4.2).
+
+Table 1: Mean cost, gap and total time to solve 10000 TSP/VRP instances after training.   
+
+<table><tr><td>PROBLEM</td><td colspan="3">TSP100</td><td colspan="3">VRP100</td></tr><tr><td>METHOD</td><td>COST</td><td>GAP</td><td>TIME</td><td>COST</td><td>GAP</td><td>TIME</td></tr><tr><td>CONCORDE[2]</td><td>7.765</td><td>0.000 %</td><td>6M</td><td></td><td></td><td></td></tr><tr><td>HYBRID GENETIC SEARCH [56,55] GUROBI[22]</td><td>7.776</td><td></td><td>31M</td><td>15.563</td><td>0.000 %</td><td>6H11M</td></tr><tr><td>LKH [24]</td><td>7.765</td><td>0.151 % 0.000%</td><td>42M</td><td>15.647</td><td>0.536 %</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>12H57M</td></tr><tr><td>GNN HEATMAP +BEAM SEARCH[26] LEARNING 2-OPT HEURISTICS [9]</td><td>7.87</td><td>1.39 %</td><td>40M</td><td></td><td></td><td></td></tr><tr><td></td><td>7.83</td><td>0.87%</td><td>41M</td><td></td><td></td><td></td></tr><tr><td>MERGED GNNHEATMAP+MCTS[17]</td><td>7.764*</td><td>0.04%</td><td>4M + 11M</td><td></td><td></td><td></td></tr><tr><td>ATTENTION MODEL + SAMPLING [29]</td><td>7.94</td><td>2.26%</td><td>1H</td><td>16.23</td><td>4.28 %</td><td>2H</td></tr><tr><td>STEP-WISE ATTENTION MODEL [60]</td><td>8.01</td><td>3.20%</td><td>29s</td><td>16.49</td><td>5.96 %</td><td>39s</td></tr><tr><td>LEARNING IMPROV. HEURISTICS [59]</td><td>7.87</td><td>1.42 %</td><td>2H</td><td>16.03</td><td>3.00 %</td><td>5H</td></tr><tr><td>ATTENTION MODEL +POMO [30]</td><td>7.77</td><td>0.14 %</td><td>1M</td><td>15.76</td><td>1.26 %</td><td>2M</td></tr><tr><td>NEUREWRITER [7]</td><td></td><td></td><td></td><td>16.10</td><td>3.45 %</td><td>1H</td></tr><tr><td>DYNAMIC ATTN.MODEL + 2-OPT [45]</td><td></td><td></td><td></td><td>16.27</td><td>4.54 %</td><td>6H</td></tr><tr><td>NEUR.LRG.NEIGHB.SEARCH[25]</td><td></td><td></td><td></td><td>15.99</td><td>2.74 %</td><td>1H</td></tr><tr><td>LEARN TO IMPROVE [35]</td><td></td><td></td><td></td><td>15.57*</td><td>1</td><td>4000H</td></tr><tr><td>DPDP10K</td><td>7.765</td><td>0.009 %</td><td>10M + 16M</td><td>15.830</td><td>1.713 %</td><td>10M+50M</td></tr><tr><td>DPDP100K</td><td>7.765</td><td>0.004%</td><td>10M+2H35M</td><td>15.694</td><td>0.843%</td><td>10M+5H48M</td></tr><tr><td>DPDP1M</td><td></td><td></td><td></td><td>15.627</td><td>0.409 %</td><td>10M + 48H27M</td></tr></table>
+
+Table 2: Mean cost, gap and total time to solve 10000 realistic [51] VRP100 instances after training.   
+
+<table><tr><td>METHOD</td><td>CoST</td><td>GAP</td><td>TIME (1 GPU OR 16 CPUs)</td><td>TIME(4 GPUs OR 32 CPUs)</td></tr><tr><td>HGS [56,55]</td><td>18050</td><td>0.000 %</td><td>7H53M</td><td>3H56M</td></tr><tr><td>LKH [24]</td><td>18133</td><td>0.507 %</td><td>25H32M</td><td>12H46M</td></tr><tr><td>DPDP 10K</td><td>18414</td><td>2.018 %</td><td>10M+50M</td><td>2M+13m</td></tr><tr><td>DPDP100K</td><td>18253</td><td>1.127 %</td><td>10M+5H48M</td><td>2M+1H27M</td></tr><tr><td>DPDP1M</td><td>18168</td><td>0.659 %</td><td>10M+48H27M</td><td>2M+12H7M</td></tr></table>
+
+# 237 4.2 Vehicle Routing Problem
+
+238 For the VRP, we train the model using 1 million instances of 100 nodes, generated according to the   
+239 distribution described by [41] and solved using one run of LKH [24]. We train using a batch size of   
+240 48 and a learning rate of $1 0 ^ { - 3 }$ (selected as the result of manual trials to best use our GPUs), for (at   
+241 most) 1500 epochs of 500 training steps (following [26]) from which we select the saved checkpoint   
+242 with the lowest validation loss. We use the validation and test sets by [29].   
+243 Table 1 shows the results compared to a recent implementation of Hybrid Genetic Search $( \mathrm { H G S } ) ^ { 5 }$ ,   
+244 a SOTA heuristic VRP solver [56, 55]. HGS is faster and improves around $0 . 5 \%$ over LKH, which   
+245 is typically considered the baseline in related work. We present the results for LKH, as well as the   
+246 strongest neural approaches and DPDP with beam sizes up to 1 million. Some results used 2000   
+247 (different) instances [35] and cannot be directly compared6. DPDP outperforms all other neural   
+248 baselines, except POMO [30], which delivers good results very quickly by exploiting symmetries in   
+249 the problem. However, as it cannot (easily) improve further with additional runtime, we consider this   
+250 contribution orthogonal to DPDP. DPDP is competitive to LKH (see also Section 4.4).   
+251 More realistic instances We also train the model and run experiments with instances with 100   
+252 nodes from a more realistic and challenging data distribution [51]. This distribution, commonly used   
+253 in the routing community, has greater variability, in terms of node clustering and demand distributions.   
+254 LKH failed to solve two of the test instances, which we found out is because LKH by default uses   
+255 a fixed number of routes equal to a lower bound, given by $\left\lceil \frac { \sum _ { i = 0 } ^ { n - 1 } d _ { i } } { \mathrm { C A P A C I T Y } } \right\rceil$ , which may be infeasible7.   
+256 Therefore we solve these instances by rerunning LKH with an unlimited number of allowed routes   
+257 (which in general gives worse results, see Section 4.4).   
+258 DPDP was run on a machine with 4 GPUs, but we also report (estimated) runtimes for 1 GPU   
+259 (1080Ti), and we compare against 16 or 32 CPUs for HGS and LKH. In Table 2 it can be seen that   
+260 the difference with LKH is, as expected, slightly larger than for the simpler dataset, but still below   
+261 $1 \%$ for beam sizes of 100K-1M. We also observed a higher validation loss, so it may be possible to   
+262 improve results using more training data. Nevertheless, finding solutions within $1 \%$ of the specialized   
+263 SOTA HGS algorithm, and even closer to LKH, is impressive for these challenging instances, and we   
+264 consider the runtime (for solving 10K instances) acceptable, especially when using multiple GPUs.
+
+# 65 4.3 TSP with Time Windows
+
+For the TSP with hard time window constraints, we use the data distribution by [6] and use their set of 100 test instances with 100 nodes. These were generated with small time windows, resulting in a small feasible search space, such that even with very small beam sizes, our DP implementation solves these instances optimally, eliminating the need for a policy. Therefore, we also consider a more difficult distribution similar to [10], which has larger time windows which are more difficult as the feasible search space is larger8 [15]. For details, see Appendix B. For both distributions, we generate training data and train the model exactly as we did for the VRP.
+
+Table 3: Mean cost, gap and total time to solve TSPTW100 instances after training.   
+
+<table><tr><td rowspan="2">PROBLEM METHOD</td><td colspan="4">SMALL TIME WINDOWS [6](100 INST.)</td><td colspan="4">LARGE TIME WINDOWS [1O] (1OK INST.)</td></tr><tr><td>COST</td><td>GAP</td><td>FAIL</td><td>TIME</td><td>COST</td><td>GAP</td><td>FAIL</td><td>TIME</td></tr><tr><td>GVNS 30x [10]</td><td>5129.58</td><td>0.000 %</td><td></td><td>7s</td><td>2432.112</td><td>0.000 %</td><td></td><td>37M15s</td></tr><tr><td>GVNS 1x [10]</td><td>5129.58</td><td>0.000%</td><td></td><td>&lt;1s</td><td>2457.974</td><td>1.063 %</td><td></td><td>1M4s</td></tr><tr><td>LKH1x [24]</td><td>5130.32</td><td>0.014 %</td><td>1.00 %</td><td>5M48s</td><td>2431.404</td><td>-0.029 %</td><td></td><td>34H58M</td></tr><tr><td>BAB-DQN*[6]</td><td>5130.51</td><td>0.018 %</td><td></td><td>25H</td><td></td><td></td><td></td><td></td></tr><tr><td>ILDS-DQN*[6]</td><td>5130.45</td><td>0.017%</td><td></td><td>25H</td><td></td><td></td><td></td><td></td></tr><tr><td>DPDP 10K</td><td>5129.58</td><td>0.000 %</td><td></td><td>6s + 1s</td><td>2431.143</td><td>-0.040 %</td><td></td><td>10M +8M7S</td></tr><tr><td>DPDP 100K</td><td>5129.58</td><td>0.000%</td><td></td><td>6s +1s</td><td>2430.880</td><td>-0.051 %</td><td></td><td>10M + 1H16M</td></tr></table>
+
+273 Table 3 shows the results for both data distributions, which are reported in terms of the difference   
+274 to General Variable Neighbourhood Search (GVNS) [10], the best open-source solver for TSPTW   
+275 we could find9, using 30 runs. For the small time window setting, both GVNS and DPDP find   
+276 optimal solutions for all 100 instances in just 7 seconds (in total, either on 16 CPUs or a single GPU).   
+277 LKH fails to solve one instance, but finds close to optimal solutions, but around 50 times slower.   
+278 $\mathrm { B a B - D Q N ^ { * } }$ and ILDS- $\mathrm { D Q N ^ { * } }$ [6], methods combining an existing solver with an RL trained neural   
+279 policy, take around 15 minutes per instance (orders of magnitudes slower) to solve most instances to   
+280 optimality. Due to complex set-up, we were unable to run BaB-DQN\* and ILDS-DQN\* ourselves for   
+281 the setting with larger time windows. In this setting, we find DPDP outperforms both LKH (where   
+282 DPDP is orders of magnitude faster) and GVNS, in both speed and solution quality. This illustrates   
+283 that DPDP, due to its nature, is especially well suited to handle constrained problems.
+
+# 4.4 Ablations
+
+Scoring policy To evaluate the value of different components of DPDP’s GNN Heat $^ +$ Potential scoring policy, we compare against other variants. GNN Heat is the version without the potential, whereas Cost Heat $^ +$ Potential and Cost Heat are variants that use a ‘heuristic’ $\begin{array} { r } { \hat { h } _ { i j } = \frac { c _ { i j } } { \operatorname* { m a x } _ { k } { c _ { i k } } } } \end{array}$ instead of the GNN. Cost directly uses the current cost of the solution, and can be seen as ‘classic’ restricted DP. Finally, BS GNN Heat $^ +$ Potential uses beam search without dynamic programming, i.e. without removing dominated solutions. To evaluate only the scoring policy, each variant uses the fully connected graph $( \mathrm { k n n } = n - 1 )$ ). Figure 3a shows the value of DPDP’s potential function, although even without it results are still significantly better than ‘classic’ heuristic DP variants using cost-based scoring policies. Also, it is clear that using DP significantly improves over a standard beam search (by removing dominated solutions). Lastly, the figure illustrates how the time for generating the heatmap using the neural network, despite its significant value, only makes up a small portion of the total runtime.
+
+(a) Different scoring policies, as well as ‘pure’ beam search, for beam sizes 1, 10, 100, 1000, 10K, 100K.
+
+(b) Beam sizes 10K, 25K, 50K, 100K, 250K, 500K, 1M, 2.5M compared against LKH(U) with 1, 2, 5 and 10 runs.
+
+![](images/675521e3344e7f9ed8a0ed9d874cc8bd17ac8ab58039bbfb330c13ad04ecab56.jpg)  
+(c) Sparsities with heatmap thresholds 0.9, 0.5, 0.2, 0.1, $1 0 ^ { \overset { \cdot } { - } 2 }$ , $1 0 ^ { - 3 }$ , $1 0 ^ { - 4 }$ , $1 0 ^ { - 5 }$ and $\mathbf { k n n } = 5$ , 10, 20, 50, 99. Beam size $1 0 0 \mathrm { K }$ .   
+Figure 3: DPDP ablations on 100 validation instances of VRP with 100 nodes.
+
+297 Beam size DPDP allows to trade off the performance vs. the runtime using the beam size $B$ (and to   
+298 some extent the graph sparsity, see Section 4.4). We illustrate this trade-off in Figure 3b, where we   
+299 evaluate DPDP on 100 validation instances for VRP, with different beam sizes from 10K to $2 . 5 \mathbf { M }$ .   
+300 We also report the trade-off curve for the LKH(U), which is the strongest baseline that can also   
+301 solve different problems. We vary the runtime using 1, 2, 5 and 10 runs (returning the best solution).   
+302 LKHU(nlimited) is the version which allows an unlimited number of routes (see Section 4.2). It is   
+303 hard to compare GPU vs CPU, so we report (estimated) runtimes for different hardware, i.e. 1 or 4   
+304 GPUs (with 3 CPUs per GPU) and 16 or 32 CPUs. We report the difference (i.e. the gap) with HGS,   
+305 analog to how results are reported in Table 1. We emphasize that in most related work (e.g. [29]), the   
+306 strongest baseline considered is one run of LKH, so we compare against a much stronger baseline.   
+307 Also, our goal is not to outperform HGS (which is SOTA and specific to VRP) or LKH, but to show   
+308 DPDP has reasonable performance, while being a flexible framework for other (routing) problems.   
+309 Graph sparsity We test the two graph sparsification strategies described in Section 3.4 as another   
+310 way to trade off performance and runtime of DPDP. In Figure 3c, we experiment with different   
+311 heatmap thresholds from $1 0 ^ { - 5 }$ to 0.9 and different values for KNN from 5 to 99 (fully connected).   
+312 The heatmap threshold strategy clearly outperforms the KNN strategy as it yields the same results   
+313 using sparser graphs (and lower runtimes). This illustrates that the heatmap threshold strategy is more   
+314 informed than the KNN strategy, confirming the value of the neural network predictions.
+
+# 15 5 Discussion
+
+In this paper we introduced Deep Policy Dynamic Programming, which combines machine learning and dynamic programming for solving vehicle routing problems. The method yields close to optimal results for TSPs with 100 nodes and is competitive to the highly optimized LKH [24] solver for VRPs with 100 nodes. On the TSP with time windows, DPDP also outperforms LKH, being significanlty faster, as well as GVNS [10], the best open source solver we could find. Given that DPDP was not specifically designed for TSPTW, and still has possibilities for improvement, we consider this an impressive and promising achievement.
+
+The constructive nature of DPDP (combined with search) allows to efficiently address hard constraints such as time windows, which are typically considered challenging in neural combinatorial optimization [5, 29] and are also difficult for local search heuristics (as they need to maintain feasibility while adapting a solution). Given our results on TSP, VRP and TSPTW, and the flexibility of DP as a framework, we think DPDP has great potential for solving many more variants of routing problems, and possibly even other problems that can be formulated using DP (e.g. job shop scheduling [21]). We hope that our work brings machine learning research for combinatorial optimization closer to the operations research (especially vehicle routing) community, by combining machine learning with DP and evaluating the resulting new framework on different data distributions used by different communities [41, 51, 6, 10].
+
+333 Scope, limitations & future work Deep learning for combinatorial optimization is a recent re  
+334 search direction, which could significantly impact the way practical optimization problems get solved   
+335 in the future. Currently, however, it is still hard to beat most SOTA problem specific solvers from the   
+336 OR community. Despite our success for TSPTW, DPDP is not yet a practical alternative in general,   
+337 but we do consider our results as highly encouraging for further research. We belief such research   
+338 could yield significant further improvement by addressing key current limitations: (1) the scalability   
+339 to larger instances, (2) the dependency on example solutions and (3) the heuristic nature of the scoring   
+340 function. First, while 100 nodes is not far from the size of common benchmarks ( $1 0 0 - 1 0 0 0$ for VRP   
+341 [51] and $2 0 - 2 0 0$ for TSPTW [10]), scaling is a challenge, mainly due to the ‘fully-connected’ $O ( n ^ { 2 } )$   
+342 graph neural network. Future work could reduce this complexity following e.g. [33]. The dependency   
+343 on example solutions from an existing solver also becomes more prominent for larger instances,   
+344 but could potentially be removed by ‘bootstrapping’ using DP itself as we, in some sense, have   
+345 done for TSPTW (see Section 3.3). Future work could iterate this process to train the model ‘tabula   
+346 rasa’ (without example solutions), where DP could be seen analogous to MCTS in AlphaZero [48].   
+347 Lastly, the heat $^ +$ potential score function is a well-motivated but heuristic function that was manually   
+348 designed as a function of the predicted heatmap. While it worked well for the three problems we   
+349 considered, it may need suitable adaption for other problems. Training this function end-to-end   
+350 [11, 58], while keeping a low computational footprint, would be an interesting topic for future work.
+
+References   
+[1] Luca Accorsi and Daniele Vigo. A fast and scalable heuristic for the solution of large-scale capacitated vehicle routing problems. Technical report, Tech. rep., University of Bologna, 2020.   
+[2] David Applegate, Robert Bixby, Vasek Chvatal, and William Cook. Concorde TSP solver, 2006.   
+[3] Richard Bellman. On the theory of dynamic programming. Proceedings of the National Academy of Sciences of the United States of America, 38(8):716, 1952.   
+[4] Richard Bellman. Dynamic programming treatment of the travelling salesman problem. Journal of the ACM (JACM), 9(1):61–63, 1962.   
+[5] Irwan Bello, Hieu Pham, Quoc V Le, Mohammad Norouzi, and Samy Bengio. Neural combinatorial optimization with reinforcement learning. arXiv preprint arXiv:1611.09940, 2016.   
+[6] Quentin Cappart, Thierry Moisan, Louis-Martin Rousseau, Isabeau Prémont-Schwarz, and Andre Cire. Combining reinforcement learning and constraint programming for combinatorial optimization. arXiv preprint arXiv:2006.01610, 2020.   
+[7] Xinyun Chen and Yuandong Tian. Learning to perform local rewriting for combinatorial optimization. In Advances in Neural Information Processing Systems, volume 32, pages 6281–6292, 2019.   
+[8] William Cook and Paul Seymour. Tour merging via branch-decomposition. INFORMS Journal on Computing, 15(3):233–248, 2003.   
+[9] Paulo Roberto de O da Costa, Jason Rhuggenaath, Yingqian Zhang, and Alp Akcay. Learning 2- opt heuristics for the traveling salesman problem via deep reinforcement learning. Proceedings of Machine Learning Research, 1:17, 2020.   
+[10] Rodrigo Ferreira Da Silva and Sebastián Urrutia. A general vns heuristic for the traveling salesman problem with time windows. Discrete Optimization, 7(4):203–211, 2010.   
+[11] Hal Daumé III and Daniel Marcu. Learning as search optimization: Approximate large margin methods for structured prediction. In Proceedings of the 22nd international conference on Machine learning, pages 169–176, 2005.   
+[12] Arthur Delarue, Ross Anderson, and Christian Tjandraatmadja. Reinforcement learning with combinatorial actions: An application to vehicle routing. Advances in Neural Information Processing Systems, 33, 2020.   
+[13] Michel Deudon, Pierre Cournut, Alexandre Lacoste, Yossiri Adulyasak, and Louis-Martin Rousseau. Learning heuristics for the TSP by policy gradient. In International Conference on the Integration of Constraint Programming, Artificial Intelligence, and Operations Research, pages 170–181. Springer, 2018.   
+[14] Edsger W Dijkstra. A note on two problems in connexion with graphs. Numerische mathematik, 1(1):269–271, 1959.   
+[15] Yvan Dumas, Jacques Desrosiers, Eric Gelinas, and Marius M Solomon. An optimal algorithm for the traveling salesman problem with time windows. Operations research, 43(2):367–371, 1995.   
+[16] Jonas K Falkner and Lars Schmidt-Thieme. Learning to solve vehicle routing problems with time windows through joint attention. arXiv preprint arXiv:2006.09100, 2020.   
+[17] Zhang-Hua Fu, Kai-Bin Qiu, and Hongyuan Zha. Generalize a small pre-trained model to arbitrarily large tsp instances. arXiv preprint arXiv:2012.10658, 2020.   
+[18] Lei Gao, Mingxiang Chen, Qichang Chen, Ganzhong Luo, Nuoyi Zhu, and Zhixin Liu. Learn to design the heuristics for vehicle routing problem. arXiv preprint arXiv:2002.08539, 2020.   
+[19] Maxime Gasse, Didier Chetelat, Nicola Ferroni, Laurent Charlin, and Andrea Lodi. Exact combinatorial optimization with graph convolutional neural networks. In Advances in Neural Information Processing Systems. [20] Joaquim Gromicho, Jelke J van Hoorn, Adrianus Leendert Kok, and Johannes MJ Schutten. Restricted dynamic programming: a flexible framework for solving realistic vrps. Computers & operations research, 39(5):902–909, 2012.   
+01 [21] Joaquim AS Gromicho, Jelke J Van Hoorn, Francisco Saldanha-da Gama, and Gerrit T Timmer. Solving the job-shop scheduling problem optimally by dynamic programming. Computers & Operations Research, 39(12):2968–2977, 2012.   
+04 [22] Gurobi Optimization, LLC. Gurobi, 2018.   
+05 [23] Michael Held and Richard M Karp. A dynamic programming approach to sequencing problems. Journal of the Society for Industrial and Applied Mathematics, 10(1):196–210, 1962. [24] Keld Helsgaun. An extension of the Lin-Kernighan-Helsgaun TSP solver for constrained traveling salesman and vehicle routing problems: Technical report. 2017. [25] André Hottung and Kevin Tierney. Neural large neighborhood search for the capacitated vehicle routing problem. arXiv preprint arXiv:1911.09539, 2019. [26] Chaitanya K Joshi, Thomas Laurent, and Xavier Bresson. An efficient graph convolutional network technique for the travelling salesman problem. arXiv preprint arXiv:1906.01227, 2019. [27] Chaitanya K Joshi, Thomas Laurent, and Xavier Bresson. On learning paradigms for the travelling salesman problem. arXiv preprint arXiv:1910.07210, 2019. [28] AL Kok, Elias W Hans, Johannes MJ Schutten, and Willem HM Zijm. A dynamic programming heuristic for vehicle routing with time-dependent travel times and required breaks. Flexible services and manufacturing journal, 22(1-2):83–108, 2010. [29] Wouter Kool, Herke van Hoof, and Max Welling. Attention, learn to solve routing problems! In International Conference on Learning Representations, 2019. [30] Yeong-Dae Kwon, Jinho Choo, Byoungjip Kim, Iljoo Yoon, Youngjune Gwon, and Seungjai Min. Pomo: Policy optimization with multiple optima for reinforcement learning. Advances in Neural Information Processing Systems, 33, 2020.   
+23 [31] Gilbert Laporte. The vehicle routing problem: An overview of exact and approximate algorithms. European journal of operational research, 59(3):345–358, 1992. [32] Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. nature, 521(7553):436, 2015. [33] Juho Lee, Yoonho Lee, Jungtaek Kim, Adam Kosiorek, Seungjin Choi, and Yee Whye Teh. Set transformer: A framework for attention-based permutation-invariant neural networks. In International Conference on Machine Learning, pages 3744–3753. PMLR, 2019. [34] Zhuwen Li, Qifeng Chen, and Vladlen Koltun. Combinatorial optimization with graph convolutional networks and guided tree search. Advances in Neural Information Processing Systems, page 539, 2018.   
+33 [35] Hao Lu, Xingwen Zhang, and Shuang Yang. A learning-based iterative method for solving vehicle routing problems. In International Conference on Learning Representations, 2020. [36] Qiang Ma, Suwen Ge, Danyang He, Darshan Thaker, and Iddo Drori. Combinatorial optimization by graph pointer networks and hierarchical reinforcement learning. arXiv preprint arXiv:1911.04936, 2019. [37] Chryssi Malandraki and Robert B Dial. A restricted dynamic programming heuristic algorithm for the time dependent traveling salesman problem. European Journal of Operational Research, 90(1):45–55, 1996.   
+41 [38] Nina Mazyavkina, Sergey Sviridov, Sergei Ivanov, and Evgeny Burnaev. Reinforcement learning for combinatorial optimization: A survey. arXiv preprint arXiv:2003.03600, 2020.   
+[39] Aristide Mingozzi, Lucio Bianco, and Salvatore Ricciardelli. Dynamic programming strategies for the traveling salesman problem with time window and precedence constraints. Operations research, 45(3):365–377, 1997.   
+[40] Vinod Nair, Sergey Bartunov, Felix Gimeno, Ingrid von Glehn, Pawel Lichocki, Ivan Lobov, Brendan O’Donoghue, Nicolas Sonnerat, Christian Tjandraatmadja, Pengming Wang, et al. Solving mixed integer programs using neural networks. arXiv preprint arXiv:2012.13349, 2020.   
+[41] MohammadReza Nazari, Afshin Oroojlooy, Lawrence Snyder, and Martin Takac. Reinforcement learning for solving the vehicle routing problem. In Advances in Neural Information Processing Systems, pages 9860–9870, 2018.   
+[42] Clara Novoa and Robert Storer. An approximate dynamic programming approach for the vehicle routing problem with stochastic demands. European Journal of Operational Research, 196(2):509–515, 2009.   
+[43] Alex Nowak, Soledad Villar, Afonso S Bandeira, and Joan Bruna. A note on learning algorithms for quadratic assignment with graph neural networks. arXiv preprint arXiv:1706.07450, 2017.   
+[44] Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017.   
+[45] Bo Peng, Jiahai Wang, and Zizhen Zhang. A deep reinforcement learning algorithm using dynamic attention model for vehicle routing problems. In International Symposium on Intelligence Computation and Applications, pages 636–650. Springer, 2019.   
+[46] Stefan Ropke and David Pisinger. An adaptive large neighborhood search heuristic for the pickup and delivery problem with time windows. Transportation science, 40(4):455–472, 2006.   
+[47] Gerhard Schrimpf, Johannes Schneider, Hermann Stamm-Wilbrandt, and Gunter Dueck. Record breaking optimization results using the ruin and recreate principle. Journal of Computational Physics, 159(2):139–171, 2000.   
+[48] David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, et al. A general reinforcement learning algorithm that masters chess, shogi, and go through self-play. Science, 362(6419):1140–1144, 2018.   
+[49] Yuan Sun, Andreas Ernst, Xiaodong Li, and Jake Weiner. Generalization of machine learning for problem reduction: a case study on travelling salesman problems. OR Spectrum, pages 1–27, 2020.   
+[50] Paolo Toth and Daniele Vigo. Vehicle routing: problems, methods, and applications. SIAM, 2014.   
+[51] Eduardo Uchoa, Diego Pecin, Artur Pessoa, Marcus Poggi, Thibaut Vidal, and Anand Subramanian. New benchmark instances for the capacitated vehicle routing problem. European Journal of Operational Research, 257(3):845–858, 2017.   
+[52] Wouter van Heeswijk and Han La Poutré. Approximate dynamic programming with neural networks in linear discrete action spaces. arXiv preprint arXiv:1902.09855, 2019.   
+[53] Jelke J. van Hoorn. Dynamic Programming for Routing and Scheduling. PhD thesis, 2016.   
+[54] Natalia Vesselinova, Rebecca Steinert, Daniel F Perez-Ramirez, and Magnus Boman. Learning combinatorial optimization on graphs: A survey with applications to networking. IEEE Access, 8:120388–120416, 2020.   
+[55] Thibaut Vidal. Hybrid genetic search for the cvrp: Open-source implementation and swap\* neighborhood. arXiv preprint arXiv:2012.10384, 2020.   
+[56] Thibaut Vidal, Teodor Gabriel Crainic, Michel Gendreau, Nadia Lahrichi, and Walter Rei. A hybrid genetic algorithm for multidepot and periodic vehicle routing problems. Operations Research, 60(3):611–624, 2012.   
+[57] Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pages 2692–2700, 2015.   
+[58] Sam Wiseman and Alexander M Rush. Sequence-to-sequence learning as beam-search optimization. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pages 1296–1306, 2016.   
+[59] Yaoxin Wu, Wen Song, Zhiguang Cao, Jie Zhang, and Andrew Lim. Learning improvement heuristics for solving routing problems. arXiv preprint arXiv:1912.05784, 2019.   
+[60] Liang Xin, Wen Song, Zhiguang Cao, and Jie Zhang. Step-wise deep learning models for solving routing problems. IEEE Transactions on Industrial Informatics, 2020.   
+[61] Shenghe Xu, Shivendra S Panwar, Murali Kodialam, and TV Lakshman. Deep neural network approximated dynamic programming for combinatorial optimization. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 1684–1691, 2020.   
+[62] Feidiao Yang, Tiancheng Jin, Tie-Yan Liu, Xiaoming Sun, and Jialin Zhang. Boosting dynamic programming with neural networks for solving np-hard problems. In Asian Conference on Machine Learning, pages 726–739. PMLR, 2018.
+
+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] Scaling and scoring policy, see discussion   
+(c) Did you discuss any potential negative societal impacts of your work? [No] We do not see any issues   
+(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] For claim that DPDP is asymptotically optimal, the DP description defines the set of assumptions and we note the beam size for which this holds.   
+(b) Did you include complete proofs of all theoretical results? [No] Optimality and complexity of full DP for TSP is already known [23, 4] (we do not claim this is a new result, we just mention it)
+
+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] Code will be available upon release   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We did a fair job to include all the information necessary to reproduce the experiments   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] For training the model, we used a standard supervised learning setup and we found training to be stable across different problems and data distributions. Due to high computational costs, we did not do multiple runs, which we consider conservative as likely results can be improved by further experiments and training with multiple seeds. As for evaluation of the algorithms on random instances, we use a large test set of 10.000 instances. As we use the same instances for our own implemented baselines, the statistical significance in such a ‘paired’ setting is much higher than would be suggested by error bars. For results directly reported from other papers, the margin is large enough with 10000 instances or we avoid strong claims. With our code, we plan to release all solutions for all test instances for the methods we evaluated ourselves.   
+(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] While not explicitly, the total computational requirement for generating training data, which requires the most compute, can be derived from solving 1M instances and the time reported for solving 10K instances in Table 1. This is a number of days (around 4) on a cluster with 10 32-core machines, per problem.
+
+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? [No] This can be found in the original repositories   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] Will be provided with the released code as URL   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No] Data is public or provided in personal communication, consent for publication was given   
+(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...
+
+560 (a) Did you include the full text of instructions given to participants and screenshots, if   
+561 applicable? [N/A]   
+562 (b) Did you describe any potential participant risks, with links to Institutional Review   
+563 Board (IRB) approvals, if applicable? [N/A]   
+564 (c) Did you include the estimated hourly wage paid to participants and the total amount   
+565 spent on participant compensation? [N/A]

parse/train/OAMrSPRRxJx/OAMrSPRRxJx_content_list.json

@@ -0,0 +1,892 @@
+[
+    {
+        "type": "text",
+        "text": "Deep Policy Dynamic Programming for Vehicle Routing Problems ",
+        "text_level": 1,
+        "bbox": [
+            281,
+            122,
+            717,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            578,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Routing problems are a class of combinatorial problems with many practical   \n2 applications. Recently, end-to-end deep learning methods have been proposed   \n3 to learn approximate solution heuristics for such problems. In contrast, classical   \n4 dynamic programming (DP) algorithms guarantee optimal solutions, but scale   \n5 badly with the problem size. We propose Deep Policy Dynamic Programming   \n6 (DPDP), which aims to combine the strengths of learned neural heuristics with   \n7 those of DP algorithms. DPDP prioritizes and restricts the DP state space using   \n8 a policy derived from a deep neural network, which is trained to predict edges   \n9 from example solutions. We evaluate our framework on the travelling salesman   \n10 problem (TSP), the vehicle routing problem (VRP) and TSP with time windows   \n11 (TSPTW) and show that the neural policy improves the performance of (restricted)   \n12 DP algorithms, making them competitive to strong alternatives such as LKH, while   \n13 also outperforming most other ‘neural approaches’ for solving TSPs, VRPs and   \n14 TSPTWs with 100 nodes. ",
+        "bbox": [
+            148,
+            348,
+            766,
+            541
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "15 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            566,
+            310,
+            584
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "16 Dynamic programming (DP) is a powerful framework for solving optimization problems by solving   \n17 smaller subproblems through the principle of optimality [3]. Famous examples are Dijkstra’s   \n18 algorithm [14] for the shortest route between two locations, and the classic Held-Karp algorithm for   \n19 the travelling salesman problem (TSP) [23, 4]. Despite their long history, dynamic programming   \n20 algorithms for vehicle routing problems (VRPs) have seen limited use in practice, primarily due to   \n21 their bad scaling performance. More recently, a line of research has attempted the use of machine   \n22 learning (especially deep learning) to automatically learn heuristics for solving routing problems   \n23 [57, 5, 41, 29, 7]. While the results are promising, most learned heuristics are not (yet) competitive   \n24 to ‘traditional’ algorithms such as LKH [24] and lack (asymptotic) guarantees on their performance.   \n25 In this paper, we propose Deep Policy Dynamic Programming (DPDP) as a framework for solving   \n26 vehicle routing problems. The key of DPDP is to combine the strengths of deep learning and DP,   \n27 by restricting the DP state space (the search space) using a policy derived from a neural network.   \n28 In Figure 1 it can be seen how the neural network indicates promising parts of the search space   \n29 (through a heatmap over the edges of the graph), which is then used by the DP algorithm to find a   \n30 good solution. DPDP is more powerful than some related ideas [62, 52, 61, 6, 34] as it combines   \n31 supervised training of a large neural network with just a single model evaluation at test time, to enable   \n32 running a large scale guided search using DP. The DP framework is flexible as it can model a variety   \n33 of realistic routing problems with difficult practical constraints [20]. We illustrate this by testing   \n34 DPDP on the TSP, the capacitated VRP and the TSP with (hard) time window constraints (TSPTW).   \n35 In more detail, the starting point of our proposed approach is a restricted dynamic programming   \n36 algorithm [20]. Such an algorithm heuristically reduces the search space by retaining only the $B$ most   \n37 promising solutions per iteration. The selection process is very important as it defines the part of the   \n38 DP state space considered and, thus, the quality of the solution found (see Fig. 2). Instead of manually   \n39 defining a selection criterion, DPDP defines it using a (sparse) heatmap of promising route segments   \n40 obtained by pre-processing the problem instance using a (deep) graph neural network (GNN) [26].   \n41 This approach is reminiscent of neural branching policies for branch-and-bound algorithms [19, 40].   \n42 In this work, we thus aim for a ‘neural boost’ of DP algorithms, by using a graph neural network   \n43 for scoring partial solutions. Prior work on ‘neural’ vehicle routing has focused on auto-regressive   \n44 models [57, 5, 13, 29], but they have high computational cost when combined with (any form of)   \n45 search, as the model needs to be evaluated for each partial solution considered. Instead, we use (for   \n46 TSP) and adapt (for VRP and TSPTW) a model to predict a heatmap indicating promising edges [26],   \n47 and define the score of a partial solution as the ‘heat’ of the edges it contains (plus an estimate of the   \n48 ‘heat-to-go’ or potential of the solution). As the neural network only needs to be evaluated once for   \n49 each instance, this enables a much larger search (defined by $B$ ), making a good trade-off between   \n50 quality and computational cost. Additionally, we can apply a threshold to the heatmap to define a   \n51 sparse graph on which to run the DP algorithm, reducing the runtime by eliminating many solutions.   \n52 Figure 2 illustrates the overall DPDP algorithm. In Section 4, we show that DPDP significantly   \n53 improves over ‘classic’ restricted DP algorithms (with the same $B$ ). Additionally, we show that   \n54 DPDP outperformes most other ‘neural’ approaches for TSP, VRP and TSPTW and is competitive   \n55 with the highly-optimized LKH solver [24] for VRP, while achieving similar results much faster for   \n56 TSP and TSPTW. For TSPTW, DPDP also outperforms the best open-source solver we could find   \n57 [10], illustrating the power of DPDP to handle difficult hard constraints (time windows).   \n59 DP has a long history as an exact solution method for routing problems [31, 50], e.g. for the TSP   \n60 with time windows [15] and precedence constraints [39], but typically limited to small problems only,   \n61 due to the curse of dimensionality. Restricted DP (with heuristic policies) has been used to address,   \n62 e.g., the time dependent TSP [37], and has been generalized into a flexible framework for VRPs with   \n63 different types of practical constraints [20]. DP approaches have also been shown to be useful in   \n64 settings with difficult practical issues such as time-dependent travel times and driving regulations [28]   \n65 or stochastic demands [42]. For a thorough investigation of modelling choices of DP for routing (and   \n66 scheduling), see [53]. For sparse graphs, alternative, but less flexible, formulations can be used [8].   \n67 Despite the flexibility, constructive DP methods have not gained much popularity compared to   \n68 heuristic search approaches such as Ruin and Recreate [47], Adaptive Large Neighborhood Search   \n69 [46], LKH [24] or FILO [1]. While highly effective, these methods are limited in their flexibility as   \n70 special operators need to be engineered for different types of problems. While restricted DP was   \n71 shown to have superior performance on realistic VRPs with many constraints [20], the performance   \n72 gap of around $10 \\%$ for standard (benchmark) VRPs (with time windows) is too large to popularize   \n73 the restricted dynamic programming approach. We argue that the missing ingredient for restricted   \n74 dynamic programming is the availability of a strong but computationally cheap policy for selecting   \n75 which solutions should be considered, which is the motivation behind DPDP.   \n76 In the machine learning community, recent advances have significantly improved deep neural networks   \n77 (DNNs) to perform tasks such as image classification and machine translation [32]. After the first   \n78 deep learning model was trained (using example solutions) to construct TSP tours [57], many   \n79 improvements have been proposed, e.g. different training strategies such as reinforcement learning   \n80 (RL) [5, 27, 12, 30] and model architectures, which enabled the same idea to be used for other   \n81 routing problems [41, 29, 13, 45, 16, 60]. Most constructive neural methods are auto-regressive,   \n82 evaluating the model many times to predict one node at the time, but other works have considered   \n83 predicting a ‘heatmap’ of promising edges at once [43, 26, 17], which allows a tour to be constructed   \n84 (using sampling or beam search) without further evaluating the model. An alternative direction is   \n85 ‘learning to search’, where a neural network is used to guide a search procedure such as local search   \n86 [7, 35, 18, 59, 25]. Some works have attempted scaling to larger instances beyond 100 nodes, which   \n87 remains challenging [36, 17]. The combination of machine learning with DP has been proposed in   \n88 limited settings [62, 52, 61]. Most related to our approach, a DP algorithm for TSPTW, guided by an   \n89 RL agent, was implemented using an existing solver [6] and a neural network predicting edges has   \n90 been combined with tree search [34] and local search for maximum independent set (MIS). For a   \n91 wider view on machine learning for routing problems and combinatorial optimization, see [38, 54]. ",
+        "bbox": [
+            147,
+            598,
+            825,
+            723
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            728,
+            825,
+            867
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            150,
+            875,
+            826,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/1c606b2da8db1f29e1a67ef5708a054b86e14e8c3a6d39cebb45c66debd49d66.jpg",
+        "image_caption": [
+            "Figure 1: Heatmap predictions (red) and solutions (colored) by DPDP (VRP depot edges omitted). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            821,
+            260
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            334,
+            825,
+            405
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            410,
+            825,
+            549
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            555,
+            825,
+            638
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/a9614c90b20b1c7af3c817ba41c3c6adfe96c5f48f6ed7ba1d72eb36ff304481.jpg",
+        "image_caption": [
+            "Figure 2: Deep Policy Dynamic Programming for the TSP. A GNN creates a (sparse) heatmap indicating promising edges, after which a tour is constructed using forward dynamic programming. In each step, at most $B$ solutions are expanded according to the heatmap policy, restricting the size of the search space. Partial solutions are dominated by shorter (lower cost) solutions with the same DP state: the same nodes visited (marked grey) and current node (indicated by dashed rectangles). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            678,
+            823,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            132,
+            825,
+            243
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            248,
+            825,
+            373
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            381,
+            825,
+            602
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "92 3 Deep Policy Dynamic Programming ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            640,
+            504,
+            659
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "93 DPDP uses an existing graph neural network [26] (which we modify for VRP and TSPTW) to predict   \n94 a heatmap of promising edges, which is used to derive the policy for scoring partial solutions in   \n95 the DP algorithm. The DP algorithm starts with a beam of a single initial (empty) solution. It then   \n96 proceeds by iterating the following steps: (1) all solutions on the beam are expanded, (2) dominated   \n97 solutions are removed for each $D P$ state, (3) the $B$ best solutions according to the scoring policy   \n98 define the beam for the next iteration. These steps are illustrated in Fig. 2. The objective function is   \n99 used to select the best solution from the final beam. The resulting algorithm is a beam search over the   \n100 DP state space (which is not a ‘standard beam search’ over the solution space!) and we call $B$ the   \n101 beam size. DPDP is asymptotically optimal as using $B = n \\cdot 2 ^ { n }$ for a TSP with $n$ nodes guarantees   \n102 optimal results, but choosing smaller $B$ allows to trade performance for computational cost.   \n103 DPDP is a generic framework that can be applied to different problems, by defining the following   \n104 ingredients: (1) the state variables to track while constructing solutions, (2) the initial solution,   \n105 (3) feasible actions to expand solutions, (4) rules to define dominated solutions and (5) a scoring   \n106 policy for selecting the $B$ solutions to keep. A solution is always (uniquely) defined as a sequence of   \n107 actions, which allows the DP algorithm to construct the final solution by backtracking. In the next   \n108 sections, we define these ingredients for the TSP, VRP and TSPTW.   \n10 We implement DPDP for Euclidean TSPs with $n$ nodes on a (sparse) graph, where the cost for edge   \n11 $( i , j )$ is given by $c _ { i j }$ , the Euclidean distance between the coordinates of nodes $i$ and $j$ .   \n112 For each partial solution, defined by a sequence of actions $^ { a }$ , the state variables are $\\displaystyle \\cos t ( \\pmb { a } )$ , the   \n113 total cost (distance), current $( a )$ , the current node, and visited $( a )$ , the set of visited nodes (including   \n114 the start node). Without loss of generality, we let 0 be the start node, so we initialize the beam at step   \n115 $t = 0$ with the empty initial solution with $\\cos ( { \\pmb a } ) = 0$ , current $( { \\pmb a } ) = 0$ and $\\mathrm { v i s i t e d } ( a ) = \\{ 0 \\}$ . At   \n116 step $t$ , the action $\\bar { a } _ { t } \\in \\{ 0 , . . . , n - 1 \\}$ indicates the next node to visit, and is a feasible action for a   \n117 partial solution $\\pmb { a } = ( a _ { 0 } , . . . , a _ { t - 1 } )$ if $( a _ { t - 1 } , a _ { t } )$ is an edge in the graph and $a _ { t } \\not \\in { \\mathrm { v i s i t e d } } ( a )$ , or, when   \n118 all are visited, if $a _ { t } = 0$ to return to the start node. When expanding the solution to $\\pmb { a } ^ { \\prime } = ( a _ { 0 } , . . . , a _ { t } )$ ,   \n119 we can compute the state variables incrementally as: ",
+        "bbox": [
+            143,
+            683,
+            825,
+            821
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            153,
+            117,
+            823,
+            145
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            151,
+            825,
+            262
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d4b094d8baaef2f8db6df18d424f660c5bbb0ea0eaa46fa2d0b5e836c483ec7c.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathrm { c o s t } ( a ^ { \\prime } ) = \\mathrm { c o s t } ( a ) + { c } _ { \\mathrm { c u r r e n t } ( a ) , a _ { t } } , \\quad \\mathrm { c u r r e n t } ( a ^ { \\prime } ) = a _ { t } , \\quad \\mathrm { v i s i t e d } ( a ^ { \\prime } ) = \\mathrm { v i s i t e d } ( a ) \\cup \\{ a _ { t } \\} . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            268,
+            799,
+            287
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "120 A (partial) solution $\\textbf { \\em a }$ is a dominated solution if there exists a (dominating) solution $\\mathbf { \\delta } \\mathbf { a } ^ { * }$ such   \n121 that visited $( { \\pmb a } ^ { * } ) = \\mathrm { v i s i t e d } ( { \\pmb a } )$ , current $( a ^ { * } ) = \\operatorname { c u r r e n t } ( a )$ and $\\mathrm { c o s t } ( { \\pmb a } ^ { * } ) < \\mathrm { c o s t } ( { \\pmb a } )$ . The tuple   \n122 (visited $( a )$ , current $( a )$ ) we refer to as the $D P$ state, so removing all dominated partial solutions,   \n123 we keep exactly one minimum-cost solution for each unique DP state1. Since a solution can only   \n124 dominate other solutions with the same set of visited nodes, we only need to remove dominated   \n125 solutions from sets of solutions with the same number of actions. Therefore, we can efficiently   \n126 execute the DP algorithm in iterations, where at step $t$ all solutions have (after $t$ actions) $t + 1$ visited   \n127 nodes (including the start node), keeping the memory need at $O ( B )$ states (with $B$ the beam size).   \n128 We define the scoring policy using a pretrained model [26], which takes as input node coordinates   \n129 and edge distances to predict a raw ‘heatmap’ value $\\hat { h } _ { i j } \\in ( 0 , 1 )$ for each edge $( i , j )$ . The model was   \n130 trained to predict optimal solutions, so $\\hat { h } _ { i j }$ can be seen as the probability that edge $( i , j )$ is in the   \n131 optimal tour. We force the heatmap to be symmetric thus we define $h _ { i j } = \\operatorname* { m a x } \\{ \\hat { h } _ { i j } , \\hat { h } _ { j i } \\}$ . The policy   \n132 is defined using the heatmap values, in such a way to select the (partial) solutions with the largest   \n133 total heat, while also taking into account the (heat) potential for the unvisited nodes. The policy thus   \n134 selects the $B$ solutions which have the highest score, defined as $\\operatorname { s c o r e } ( { a } ) = \\operatorname { h e a t } ( { a } ) + \\operatorname { p o t e n t i a l } ( { a } )$ ,   \n135 with $\\begin{array} { r } { \\mathrm { h e a t } ( { \\pmb a } ) = \\sum _ { i = 1 } ^ { t - 1 } h _ { a _ { i - 1 } , a _ { i } } } \\end{array}$ , i.e. the sum of the heat of the edges, which can be computed   \n136 incrementally when expanding a solution. The potential is added as an estimate of the ‘heat-to  \n137 go’ (similar to the heuristic in $A ^ { * }$ search) for the remaining nodes, and avoids the ‘greedy pitfall’   \n138 of selecting the best edges while skipping over nearby nodes, which would prevent good edges   \n139 from being used later. It is defined as potentia $\\begin{array} { r } { \\mathsf { l } ( \\pmb { a } ) = \\bar { \\mathrm { p o t e n t i a l } } _ { 0 } ( \\pmb { a } ) + \\sum _ { i \\notin \\mathrm { v i s i t e d } ( \\pmb { a } ) } } \\end{array}$ potential ${ \\bf \\nabla } _ { \\mathrm { { i } } } ( { \\bf a } )$   \n140 with potentiali(a) = wi Pj6∈visited(a) , where $w _ { i }$ is the node potential weight given by   \n141 $\\begin{array} { r } { w _ { i } = ( \\operatorname* { m a x } _ { j } h _ { j i } ) \\cdot ( 1 - 0 . 1 ( \\frac { c _ { i 0 } } { \\operatorname* { m a x } _ { j } c _ { j 0 } } - \\overline { { 0 . 5 } } ) ) } \\end{array}$ . By normalizing the heatmap values for incoming   \n142 edges, the (remaining) potential for node $i$ is initially equal to $w _ { i }$ but decreases as good edges   \n143 become infeasible due to neighbours being visited. The node potential weight $w _ { i }$ is equal to the   \n144 maximum incoming edge heatmap value (an upper bound to the heat contributed by node $i$ ), which   \n145 gets multiplied by a factor 0.95 to 1.05 to give a higher weight to nodes closer to the start node, which   \n146 we found helps to encourage the algorithm to keep edges that enable to return to the start node. The   \n147 overall heat $^ +$ potential function identifies promising partial solutions and is computationally cheap. ",
+        "bbox": [
+            140,
+            294,
+            825,
+            405
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            410,
+            826,
+            714
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Vehicle Routing Problem ",
+        "text_level": 1,
+        "bbox": [
+            165,
+            729,
+            385,
+            744
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For the VRP, we add a special depot node to the graph, indicated by DEP. Each node $i$ has a demand $d _ { i }$ , and the goal is to find multiple routes, which have a limited capacity denoted by CAPACITY. ",
+        "bbox": [
+            160,
+            756,
+            823,
+            785
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Additionally to the TSP state variables $\\displaystyle \\cos t ( a )$ , $\\mathrm { c u r r e n t } ( a )$ and visited $( a )$ , we keep track of capacity $( a )$ , which is the remaining capacity in the current route/vehicle. A solution starts at the depot, so we initialize the beam at step $t = 0$ with the empty initial solution with $\\mathrm { c o s t } ( \\pmb { a } ) = 0$ , ${ \\mathrm { c u r r e n t } } ( { \\pmb a } ) = { \\mathrm { D E P } } , { \\mathrm { v i s i t e d } } ( { \\pmb a } ) = \\emptyset$ and capacity $( a ) =$ CAPACITY. For the VRP, we do not consider visiting the depot as a separate action. Instead, we define $2 n$ actions, where $a _ { t } \\in \\{ 0 , . . . , 2 n - 1 \\}$ . The actions $0 , . . . , n - 1$ indicate a direct move from the current node to node $a _ { t }$ , whereas the actions ",
+        "bbox": [
+            173,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "157 $n , . . . , 2 n - 1$ indicate a move to node $a _ { t } - n$ via the depot. Feasible actions are those that move   \n158 to unvisited nodes via edges in the graph and obey the following constraints. For the first action   \n159 $a _ { 0 }$ there is no choice and we constrain (for convenience of implementation) $a _ { 0 } \\in \\{ n , . . . , 2 n - 1 \\}$ .   \n160 A direct move $( a _ { t } < n )$ is only feasible if $d _ { a _ { t } } \\leq \\mathrm { c a p a c i t y } ( { \\pmb a } )$ and updates the state similar to TSP   \n161 but reduces remaining capacity by $d _ { a _ { t } }$ . A move via the depot is always feasible (respecting the   \n162 163 graph edges and assuming demand, but incurs the ‘via $d _ { i } \\leq \\mathrm { C A P A C I T Y } \\forall i )$ $c _ { i j } ^ { \\tt D E P } = c _ { i , \\tt D E P } + c _ { \\tt D E P , , j }$ e vehicle CAPACITY before subtracting. When all nodes are visited, we allow a   \n164 special action to return to the depot. This somewhat unusual way of representing a CVRP solution   \n165 has desirable properties similar to the TSP formulation: at step $t$ we have exactly $t$ nodes visited, and   \n166 we can run the DP in iterations, removing dominated solutions at each step $t$ .   \n167 For VRP, a partial solution $^ { a }$ is a dominated solution dominated by $\\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\overline { { \\delta \\delta } } \\mathbf { \\delta } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm \\mathrm { ~ } \\mathrm { ~ } \\mathrm \\delta \\mathrm { ~ } \\mathrm { ~ } \\delta \\mathrm \\mathrm { ~ } \\delta \\mathrm \\mathrm { ~ } \\delta \\mathrm \\mathrm { ~ } \\delta \\mathrm \\mathrm \\delta \\mathrm \\mathrm { ~ ~ } \\delta \\delta \\mathrm \\delta \\mathrm \\mathrm \\delta \\mathrm \\delta \\mathrm \\mathrm \\delta \\mathrm \\delta \\delta \\mathrm \\delta \\delta \\mathrm \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta $ if v $\\operatorname { i s i t e d } ( { \\pmb a } ^ { * } ) = \\operatorname { v i s i t e d } ( { \\pmb a } )$   \n168 and current $( a ^ { * } ) = \\mathrm { c u r r e n t } ( a )$ (i.e. $\\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } ( \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } ) \\delta \\mathbf { \\delta } ( \\delta \\mathbf { \\delta } ) \\delta \\mathbf { \\delta } ( \\delta \\mathbf { \\delta } ) \\delta \\delta \\mathbf { \\delta \\delta } ( \\delta \\mathbf { \\delta } ) \\delta \\delta ( \\delta \\mathbf { \\delta } \\mathrm { \\delta \\delta } ) \\delta \\delta \\delta ( \\delta \\delta \\mathbf { \\delta } \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta$ corresponds to the same DP state) and $\\mathrm { c o s t } ( { \\pmb a } ^ { * } ) \\leq \\mathrm { c o s t } ( { \\pmb a } )$   \n169 and capacity $( a ^ { * } ) \\geq \\mathrm { c a p a c i t y } ( a )$ , with at least one of the two inequalities being strict. This means   \n170 that for each DP state, given by the set of visited nodes and the current node, we do not only keep   \n171 the (single) solution with lowest cost (as in the TSP algorithm), but keep the complete set of pareto  \n172 efficient solutions in terms of cost and remaining vehicle capacity. This is because a higher cost   \n173 partial solution may still be preferred if it has more remaining vehicle capacity, and vice versa.   \n174 For the VRP scoring policy, we modify the model [26] to include the depot node and demands. The   \n175 special depot node gets a separate learned initial embedding parameter, and we add additional edge   \n176 types for connections to the depot, to mark the depot as being special. Additionally, each node gets   \n177 an extra input (next to its coordinates) corresponding to $d _ { i }$ /CAPACITY (where we set $d _ { \\tt D E P } = 0 _ { , }$ ).   \n178 Apart from this, the model remains exactly the same2. The model is trained on example solutions   \n179 from LKH [24] (see Section 4.2), which are not optimal, but still provide a useful training signal.   \n180 Compared to TSP, the definition of the heat is slightly changed to accommodate for the ‘via-depot   \n181 actions’ and is best defined incrementally using the ‘via-depot heat’ $h _ { i j } ^ { \\tt D E P } = h _ { i , \\tt D E P } \\cdot h _ { \\tt D E P , \\it j } \\cdot \\bar { 0 } . 1 .$   \n182 where multiplication is used to keep heat values interpretable as probabilities and in the range $( 0 , 1 )$ .   \n183 The additional penalty factor of 0.1 for visiting the depot encourages the algorithm to minimize the   \n184 number of vehicles/routes. The initial heat is 0 and when expanding a solution $\\textbf { \\em a }$ to $\\mathbf { { a } ^ { \\prime } }$ using action   \n185 $a _ { t }$ , the heat is incremented with either $h _ { \\mathrm { c u r r e n t } ( \\mathbf { a } ) , a _ { t } }$ (if $a _ { t } < n )$ or hDEPcurrent(a),at−n (if at ≥ n). The   \n186 potential is defined similarly to TSP, replacing the start node 0 by DEP. ",
+        "bbox": [
+            140,
+            90,
+            825,
+            229
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            236,
+            825,
+            333
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            339,
+            826,
+            523
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Travelling Salesman Problem with Time Windows ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            539,
+            560,
+            554
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "188 For the TSPTW, we also have a special depot $/$ start node 0, and each node $i$ has a time window   \n189 defined by $( l _ { i } , u _ { i } )$ in which the node should be visited, assuming travel time is equal to cost/distance.   \n190 It is allowed to wait if arrival at a node is before $l _ { i }$ , but arrival cannot be after $u _ { i }$ (i.e. the constraint is   \n191 hard). We consider the objective to be minimizing total cost, but minimizing total time (or makespan)   \n192 only requires training on different example solutions. Due to the hard constraints, TSPTW is typically   \n193 considered more challenging to solve than plain TSP, for which every solution is feasible. ",
+        "bbox": [
+            145,
+            564,
+            825,
+            647
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The state variables and initial solution are equal to TSP except that we add $\\mathrm { t i m e } ( a )$ which is initially $0 ( = l _ { 0 } )$ . Feasible actions $a _ { t } \\in \\{ 0 , . . . , n - 1 \\}$ are those that move to unvisited nodes via edges in the graph such that the arrival time is no later than $u _ { a _ { t } }$ and do not directly eliminate the possibility to visit other nodes in time3. Expanding a solution $\\textbf { \\em a }$ to $\\mathbf { { \\boldsymbol { a } } } ^ { \\prime }$ using action $a _ { t }$ updates the time as $\\mathrm { t i m e } ( { \\pmb a } ^ { \\prime } ) = \\mathrm { m a x } \\{ \\mathrm { t i m e } ( { \\pmb a } ) + c _ { \\mathrm { c u r r e n t } ( { \\pmb a } ) , { \\pmb a } _ { t } } , \\bar { l } _ { { \\pmb a } _ { t } } \\}$ . ",
+        "bbox": [
+            169,
+            654,
+            825,
+            726
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For each DP state, we keep all efficient solutions in terms of cost and time, so a partial solution $\\textbf { \\em a }$ is a dominated solution dominated by $\\mathbf { \\delta } \\mathbf { \\mathbf { \\vec { a } } } ^ { * }$ if $\\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\mathbf { \\delta } \\overline { { \\delta \\delta } } \\mathbf { \\delta } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm { ~ } \\mathrm \\mathrm { ~ } \\mathrm { ~ } \\mathrm \\delta \\mathrm { ~ } \\mathrm { ~ } \\delta \\mathrm \\mathrm { ~ } \\delta \\mathrm \\mathrm { ~ } \\delta \\mathrm \\mathrm { ~ } \\delta \\mathrm \\mathrm \\delta \\mathrm \\mathrm { ~ ~ } \\delta \\delta \\mathrm \\delta \\mathrm \\mathrm \\delta \\mathrm \\delta \\mathrm \\mathrm \\delta \\mathrm \\delta \\delta \\mathrm \\delta \\delta \\mathrm \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta \\delta $ has the same DP state $( \\mathrm { v i s i t e d } ( { \\pmb a } ^ { * } ) = \\mathrm { v i s i t e d } ( { \\pmb a } )$ and current $( { \\pmb a } ^ { * } ) = \\mathrm { c u r r e n t } ( { \\pmb a } ) )$ and is strictly better in terms of cost and time, i.e. $\\mathrm { c o s t } ( { \\pmb a } ^ { * } ) \\leq \\mathrm { c o s t } ( { \\pmb a } )$ and $\\mathrm { t i m e } ( a ^ { * } ) \\leq \\mathrm { t i m e } ( a )$ , with at least one of the two inequalities being strict. ",
+        "bbox": [
+            168,
+            729,
+            825,
+            786
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The model [26] for the scoring policy is adapted to include the time windows $( l _ { i } , u _ { i } )$ as node features (in the same unit as coordinates and costs), and we use a special embedding for the depot similar to VRP. Due to the time dimension, a TSPTW solution is directed, and edge $( i , j )$ may be good whereas $( j , i )$ may be not, so we adapt the model to enable predictions $h _ { i j } \\neq h _ { j i }$ (see details in Appendix B). We generated example training solutions using (heuristic) DP with a large beam size, which was faster than using LKH. Given the heat predictions, the score (heat $^ +$ potential) is exactly as for TSP. ",
+        "bbox": [
+            173,
+            791,
+            825,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As described, the DP algorithm can take into account a sparse graph to define feasible expansions. As our problems are defined on sets of nodes rather than graphs, the use of a sparse graph is an artificial design choice, which allows to significantly reduce the runtime but may sacrifice the possibility to find good or optimal tours. We propose two different strategies for defining the sparse graph on which to run the DP: thresholding the heatmap values $h _ { i j }$ and using the K-nearest neighbour (KNN) graph. By default, we use a (low) heatmap threshold of $\\mathrm { { 1 0 ^ { - 5 } } }$ , which rules out most of the edges as the model confidently predicts (close to) 0 for most edges. This is a secondary way to leverage the neural network (independent of the scoring policy), which can be seen as a form of learned problem reduction [49]. For symmetric problems (TSP and VRP), we add KNN edges in both directions. For the VRP, we additionally connect each node to the depot (and vice versa) to ensure feasibility. ",
+        "bbox": [
+            173,
+            118,
+            825,
+            257
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "20 3.5 Implementation $\\pmb { \\& }$ hyperparameters ",
+        "text_level": 1,
+        "bbox": [
+            158,
+            277,
+            465,
+            292
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We implement DPDP using PyTorch [44] to leverage batched computation on the GPU. For details, see Appendix A. Our code is publicly available. 4 DPDP has very few hyperparameters, but the heatmap threshold of $1 0 ^ { - 5 }$ and details like the functional form of e.g. the scoring policy are ‘educated guesses’ or manually tuned on a few validation instances and can likely be improved. The runtime is influenced by implementation choices which were manually selected using a few validation instances. ",
+        "bbox": [
+            173,
+            305,
+            825,
+            375
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            397,
+            312,
+            415
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Travelling Salesman Problem ",
+        "text_level": 1,
+        "bbox": [
+            165,
+            431,
+            416,
+            446
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Table 1 we report our main results for DPDP with beam sizes of 10K (10 thousand) and 100K, for the TSP with 100 nodes on a commonly used test set [29]. We report results using Concorde [2], LKH [24] and Gurobi [22], as well as recent results of the strongest methods using neural networks (‘neural approaches’) from literature. Running times for solving 10000 instances after training should be taken as rough indications as some are on different machines, typically with 1 GPU or a many-core CPU (8 - 32). The costs indicated with \\* are not directly comparable due to slight dataset differences [17]. Times for generating heatmaps (if applicable) is reported separately (as the first term) from the running time for MCTS [17] or DP. DPDP achieves close to optimal results, strictly outperforming the neural baselines achieving better results in less time (except POMO [30], see Section 4.2). ",
+        "bbox": [
+            173,
+            458,
+            825,
+            584
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/b7c2cd01f3d14f2e94738a44a97c7831f483c721c12091224f1a7902f32bdb00.jpg",
+        "table_caption": [
+            "Table 1: Mean cost, gap and total time to solve 10000 TSP/VRP instances after training. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>PROBLEM</td><td colspan=\"3\">TSP100</td><td colspan=\"3\">VRP100</td></tr><tr><td>METHOD</td><td>COST</td><td>GAP</td><td>TIME</td><td>COST</td><td>GAP</td><td>TIME</td></tr><tr><td>CONCORDE[2]</td><td>7.765</td><td>0.000 %</td><td>6M</td><td></td><td></td><td></td></tr><tr><td>HYBRID GENETIC SEARCH [56,55] GUROBI[22]</td><td>7.776</td><td></td><td>31M</td><td>15.563</td><td>0.000 %</td><td>6H11M</td></tr><tr><td>LKH [24]</td><td>7.765</td><td>0.151 % 0.000%</td><td>42M</td><td>15.647</td><td>0.536 %</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>12H57M</td></tr><tr><td>GNN HEATMAP +BEAM SEARCH[26] LEARNING 2-OPT HEURISTICS [9]</td><td>7.87</td><td>1.39 %</td><td>40M</td><td></td><td></td><td></td></tr><tr><td></td><td>7.83</td><td>0.87%</td><td>41M</td><td></td><td></td><td></td></tr><tr><td>MERGED GNNHEATMAP+MCTS[17]</td><td>7.764*</td><td>0.04%</td><td>4M + 11M</td><td></td><td></td><td></td></tr><tr><td>ATTENTION MODEL + SAMPLING [29]</td><td>7.94</td><td>2.26%</td><td>1H</td><td>16.23</td><td>4.28 %</td><td>2H</td></tr><tr><td>STEP-WISE ATTENTION MODEL [60]</td><td>8.01</td><td>3.20%</td><td>29s</td><td>16.49</td><td>5.96 %</td><td>39s</td></tr><tr><td>LEARNING IMPROV. HEURISTICS [59]</td><td>7.87</td><td>1.42 %</td><td>2H</td><td>16.03</td><td>3.00 %</td><td>5H</td></tr><tr><td>ATTENTION MODEL +POMO [30]</td><td>7.77</td><td>0.14 %</td><td>1M</td><td>15.76</td><td>1.26 %</td><td>2M</td></tr><tr><td>NEUREWRITER [7]</td><td></td><td></td><td></td><td>16.10</td><td>3.45 %</td><td>1H</td></tr><tr><td>DYNAMIC ATTN.MODEL + 2-OPT [45]</td><td></td><td></td><td></td><td>16.27</td><td>4.54 %</td><td>6H</td></tr><tr><td>NEUR.LRG.NEIGHB.SEARCH[25]</td><td></td><td></td><td></td><td>15.99</td><td>2.74 %</td><td>1H</td></tr><tr><td>LEARN TO IMPROVE [35]</td><td></td><td></td><td></td><td>15.57*</td><td>1</td><td>4000H</td></tr><tr><td>DPDP10K</td><td>7.765</td><td>0.009 %</td><td>10M + 16M</td><td>15.830</td><td>1.713 %</td><td>10M+50M</td></tr><tr><td>DPDP100K</td><td>7.765</td><td>0.004%</td><td>10M+2H35M</td><td>15.694</td><td>0.843%</td><td>10M+5H48M</td></tr><tr><td>DPDP1M</td><td></td><td></td><td></td><td>15.627</td><td>0.409 %</td><td>10M + 48H27M</td></tr></table>",
+        "bbox": [
+            191,
+            671,
+            803,
+            902
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/03bf7810883b4f70c93ed7b60c7e3fadd2f51d8f1b489bd8ee619c2edcb60f4e.jpg",
+        "table_caption": [
+            "Table 2: Mean cost, gap and total time to solve 10000 realistic [51] VRP100 instances after training. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>METHOD</td><td>CoST</td><td>GAP</td><td>TIME (1 GPU OR 16 CPUs)</td><td>TIME(4 GPUs OR 32 CPUs)</td></tr><tr><td>HGS [56,55]</td><td>18050</td><td>0.000 %</td><td>7H53M</td><td>3H56M</td></tr><tr><td>LKH [24]</td><td>18133</td><td>0.507 %</td><td>25H32M</td><td>12H46M</td></tr><tr><td>DPDP 10K</td><td>18414</td><td>2.018 %</td><td>10M+50M</td><td>2M+13m</td></tr><tr><td>DPDP100K</td><td>18253</td><td>1.127 %</td><td>10M+5H48M</td><td>2M+1H27M</td></tr><tr><td>DPDP1M</td><td>18168</td><td>0.659 %</td><td>10M+48H27M</td><td>2M+12H7M</td></tr></table>",
+        "bbox": [
+            225,
+            125,
+            769,
+            223
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "237 4.2 Vehicle Routing Problem ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            250,
+            385,
+            265
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "238 For the VRP, we train the model using 1 million instances of 100 nodes, generated according to the   \n239 distribution described by [41] and solved using one run of LKH [24]. We train using a batch size of   \n240 48 and a learning rate of $1 0 ^ { - 3 }$ (selected as the result of manual trials to best use our GPUs), for (at   \n241 most) 1500 epochs of 500 training steps (following [26]) from which we select the saved checkpoint   \n242 with the lowest validation loss. We use the validation and test sets by [29].   \n243 Table 1 shows the results compared to a recent implementation of Hybrid Genetic Search $( \\mathrm { H G S } ) ^ { 5 }$ ,   \n244 a SOTA heuristic VRP solver [56, 55]. HGS is faster and improves around $0 . 5 \\%$ over LKH, which   \n245 is typically considered the baseline in related work. We present the results for LKH, as well as the   \n246 strongest neural approaches and DPDP with beam sizes up to 1 million. Some results used 2000   \n247 (different) instances [35] and cannot be directly compared6. DPDP outperforms all other neural   \n248 baselines, except POMO [30], which delivers good results very quickly by exploiting symmetries in   \n249 the problem. However, as it cannot (easily) improve further with additional runtime, we consider this   \n250 contribution orthogonal to DPDP. DPDP is competitive to LKH (see also Section 4.4).   \n251 More realistic instances We also train the model and run experiments with instances with 100   \n252 nodes from a more realistic and challenging data distribution [51]. This distribution, commonly used   \n253 in the routing community, has greater variability, in terms of node clustering and demand distributions.   \n254 LKH failed to solve two of the test instances, which we found out is because LKH by default uses   \n255 a fixed number of routes equal to a lower bound, given by $\\left\\lceil \\frac { \\sum _ { i = 0 } ^ { n - 1 } d _ { i } } { \\mathrm { C A P A C I T Y } } \\right\\rceil$ , which may be infeasible7.   \n256 Therefore we solve these instances by rerunning LKH with an unlimited number of allowed routes   \n257 (which in general gives worse results, see Section 4.4).   \n258 DPDP was run on a machine with 4 GPUs, but we also report (estimated) runtimes for 1 GPU   \n259 (1080Ti), and we compare against 16 or 32 CPUs for HGS and LKH. In Table 2 it can be seen that   \n260 the difference with LKH is, as expected, slightly larger than for the simpler dataset, but still below   \n261 $1 \\%$ for beam sizes of 100K-1M. We also observed a higher validation loss, so it may be possible to   \n262 improve results using more training data. Nevertheless, finding solutions within $1 \\%$ of the specialized   \n263 SOTA HGS algorithm, and even closer to LKH, is impressive for these challenging instances, and we   \n264 consider the runtime (for solving 10K instances) acceptable, especially when using multiple GPUs. ",
+        "bbox": [
+            143,
+            277,
+            825,
+            347
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            353,
+            825,
+            464
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            483,
+            826,
+            590
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            597,
+            825,
+            694
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "65 4.3 TSP with Time Windows ",
+        "text_level": 1,
+        "bbox": [
+            155,
+            713,
+            385,
+            728
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the TSP with hard time window constraints, we use the data distribution by [6] and use their set of 100 test instances with 100 nodes. These were generated with small time windows, resulting in a small feasible search space, such that even with very small beam sizes, our DP implementation solves these instances optimally, eliminating the need for a policy. Therefore, we also consider a more difficult distribution similar to [10], which has larger time windows which are more difficult as the feasible search space is larger8 [15]. For details, see Appendix B. For both distributions, we generate training data and train the model exactly as we did for the VRP. ",
+        "bbox": [
+            173,
+            741,
+            825,
+            839
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/28b80a630028fb539e57abf918e3980a4a325d0952f774a2846eea6c6c6ef222.jpg",
+        "table_caption": [
+            "Table 3: Mean cost, gap and total time to solve TSPTW100 instances after training. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">PROBLEM METHOD</td><td colspan=\"4\">SMALL TIME WINDOWS [6](100 INST.)</td><td colspan=\"4\">LARGE TIME WINDOWS [1O] (1OK INST.)</td></tr><tr><td>COST</td><td>GAP</td><td>FAIL</td><td>TIME</td><td>COST</td><td>GAP</td><td>FAIL</td><td>TIME</td></tr><tr><td>GVNS 30x [10]</td><td>5129.58</td><td>0.000 %</td><td></td><td>7s</td><td>2432.112</td><td>0.000 %</td><td></td><td>37M15s</td></tr><tr><td>GVNS 1x [10]</td><td>5129.58</td><td>0.000%</td><td></td><td>&lt;1s</td><td>2457.974</td><td>1.063 %</td><td></td><td>1M4s</td></tr><tr><td>LKH1x [24]</td><td>5130.32</td><td>0.014 %</td><td>1.00 %</td><td>5M48s</td><td>2431.404</td><td>-0.029 %</td><td></td><td>34H58M</td></tr><tr><td>BAB-DQN*[6]</td><td>5130.51</td><td>0.018 %</td><td></td><td>25H</td><td></td><td></td><td></td><td></td></tr><tr><td>ILDS-DQN*[6]</td><td>5130.45</td><td>0.017%</td><td></td><td>25H</td><td></td><td></td><td></td><td></td></tr><tr><td>DPDP 10K</td><td>5129.58</td><td>0.000 %</td><td></td><td>6s + 1s</td><td>2431.143</td><td>-0.040 %</td><td></td><td>10M +8M7S</td></tr><tr><td>DPDP 100K</td><td>5129.58</td><td>0.000%</td><td></td><td>6s +1s</td><td>2430.880</td><td>-0.051 %</td><td></td><td>10M + 1H16M</td></tr></table>",
+        "bbox": [
+            200,
+            117,
+            794,
+            238
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "273 Table 3 shows the results for both data distributions, which are reported in terms of the difference   \n274 to General Variable Neighbourhood Search (GVNS) [10], the best open-source solver for TSPTW   \n275 we could find9, using 30 runs. For the small time window setting, both GVNS and DPDP find   \n276 optimal solutions for all 100 instances in just 7 seconds (in total, either on 16 CPUs or a single GPU).   \n277 LKH fails to solve one instance, but finds close to optimal solutions, but around 50 times slower.   \n278 $\\mathrm { B a B - D Q N ^ { * } }$ and ILDS- $\\mathrm { D Q N ^ { * } }$ [6], methods combining an existing solver with an RL trained neural   \n279 policy, take around 15 minutes per instance (orders of magnitudes slower) to solve most instances to   \n280 optimality. Due to complex set-up, we were unable to run BaB-DQN\\* and ILDS-DQN\\* ourselves for   \n281 the setting with larger time windows. In this setting, we find DPDP outperforms both LKH (where   \n282 DPDP is orders of magnitude faster) and GVNS, in both speed and solution quality. This illustrates   \n283 that DPDP, due to its nature, is especially well suited to handle constrained problems. ",
+        "bbox": [
+            138,
+            273,
+            826,
+            426
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 Ablations ",
+        "text_level": 1,
+        "bbox": [
+            163,
+            448,
+            279,
+            462
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Scoring policy To evaluate the value of different components of DPDP’s GNN Heat $^ +$ Potential scoring policy, we compare against other variants. GNN Heat is the version without the potential, whereas Cost Heat $^ +$ Potential and Cost Heat are variants that use a ‘heuristic’ $\\begin{array} { r } { \\hat { h } _ { i j } = \\frac { c _ { i j } } { \\operatorname* { m a x } _ { k } { c _ { i k } } } } \\end{array}$ instead of the GNN. Cost directly uses the current cost of the solution, and can be seen as ‘classic’ restricted DP. Finally, BS GNN Heat $^ +$ Potential uses beam search without dynamic programming, i.e. without removing dominated solutions. To evaluate only the scoring policy, each variant uses the fully connected graph $( \\mathrm { k n n } = n - 1 )$ ). Figure 3a shows the value of DPDP’s potential function, although even without it results are still significantly better than ‘classic’ heuristic DP variants using cost-based scoring policies. Also, it is clear that using DP significantly improves over a standard beam search (by removing dominated solutions). Lastly, the figure illustrates how the time for generating the heatmap using the neural network, despite its significant value, only makes up a small portion of the total runtime. ",
+        "bbox": [
+            173,
+            474,
+            826,
+            643
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(a) Different scoring policies, as well as ‘pure’ beam search, for beam sizes 1, 10, 100, 1000, 10K, 100K. ",
+        "bbox": [
+            173,
+            824,
+            383,
+            873
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(b) Beam sizes 10K, 25K, 50K, 100K, 250K, 500K, 1M, 2.5M compared against LKH(U) with 1, 2, 5 and 10 runs. ",
+        "bbox": [
+            393,
+            824,
+            604,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/675521e3344e7f9ed8a0ed9d874cc8bd17ac8ab58039bbfb330c13ad04ecab56.jpg",
+        "image_caption": [
+            "(c) Sparsities with heatmap thresholds 0.9, 0.5, 0.2, 0.1, $1 0 ^ { \\overset { \\cdot } { - } 2 }$ , $1 0 ^ { - 3 }$ , $1 0 ^ { - 4 }$ , $1 0 ^ { - 5 }$ and $\\mathbf { k n n } = 5$ , 10, 20, 50, 99. Beam size $1 0 0 \\mathrm { K }$ . ",
+            "Figure 3: DPDP ablations on 100 validation instances of VRP with 100 nodes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            705,
+            823,
+            815
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "297 Beam size DPDP allows to trade off the performance vs. the runtime using the beam size $B$ (and to   \n298 some extent the graph sparsity, see Section 4.4). We illustrate this trade-off in Figure 3b, where we   \n299 evaluate DPDP on 100 validation instances for VRP, with different beam sizes from 10K to $2 . 5 \\mathbf { M }$ .   \n300 We also report the trade-off curve for the LKH(U), which is the strongest baseline that can also   \n301 solve different problems. We vary the runtime using 1, 2, 5 and 10 runs (returning the best solution).   \n302 LKHU(nlimited) is the version which allows an unlimited number of routes (see Section 4.2). It is   \n303 hard to compare GPU vs CPU, so we report (estimated) runtimes for different hardware, i.e. 1 or 4   \n304 GPUs (with 3 CPUs per GPU) and 16 or 32 CPUs. We report the difference (i.e. the gap) with HGS,   \n305 analog to how results are reported in Table 1. We emphasize that in most related work (e.g. [29]), the   \n306 strongest baseline considered is one run of LKH, so we compare against a much stronger baseline.   \n307 Also, our goal is not to outperform HGS (which is SOTA and specific to VRP) or LKH, but to show   \n308 DPDP has reasonable performance, while being a flexible framework for other (routing) problems.   \n309 Graph sparsity We test the two graph sparsification strategies described in Section 3.4 as another   \n310 way to trade off performance and runtime of DPDP. In Figure 3c, we experiment with different   \n311 heatmap thresholds from $1 0 ^ { - 5 }$ to 0.9 and different values for KNN from 5 to 99 (fully connected).   \n312 The heatmap threshold strategy clearly outperforms the KNN strategy as it yields the same results   \n313 using sparser graphs (and lower runtimes). This illustrates that the heatmap threshold strategy is more   \n314 informed than the KNN strategy, confirming the value of the neural network predictions. ",
+        "bbox": [
+            140,
+            90,
+            826,
+            257
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            272,
+            825,
+            356
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "15 5 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            151,
+            375,
+            292,
+            391
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper we introduced Deep Policy Dynamic Programming, which combines machine learning and dynamic programming for solving vehicle routing problems. The method yields close to optimal results for TSPs with 100 nodes and is competitive to the highly optimized LKH [24] solver for VRPs with 100 nodes. On the TSP with time windows, DPDP also outperforms LKH, being significanlty faster, as well as GVNS [10], the best open source solver we could find. Given that DPDP was not specifically designed for TSPTW, and still has possibilities for improvement, we consider this an impressive and promising achievement. ",
+        "bbox": [
+            173,
+            406,
+            825,
+            502
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The constructive nature of DPDP (combined with search) allows to efficiently address hard constraints such as time windows, which are typically considered challenging in neural combinatorial optimization [5, 29] and are also difficult for local search heuristics (as they need to maintain feasibility while adapting a solution). Given our results on TSP, VRP and TSPTW, and the flexibility of DP as a framework, we think DPDP has great potential for solving many more variants of routing problems, and possibly even other problems that can be formulated using DP (e.g. job shop scheduling [21]). We hope that our work brings machine learning research for combinatorial optimization closer to the operations research (especially vehicle routing) community, by combining machine learning with DP and evaluating the resulting new framework on different data distributions used by different communities [41, 51, 6, 10]. ",
+        "bbox": [
+            161,
+            508,
+            825,
+            648
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "333 Scope, limitations & future work Deep learning for combinatorial optimization is a recent re  \n334 search direction, which could significantly impact the way practical optimization problems get solved   \n335 in the future. Currently, however, it is still hard to beat most SOTA problem specific solvers from the   \n336 OR community. Despite our success for TSPTW, DPDP is not yet a practical alternative in general,   \n337 but we do consider our results as highly encouraging for further research. We belief such research   \n338 could yield significant further improvement by addressing key current limitations: (1) the scalability   \n339 to larger instances, (2) the dependency on example solutions and (3) the heuristic nature of the scoring   \n340 function. First, while 100 nodes is not far from the size of common benchmarks ( $1 0 0 - 1 0 0 0$ for VRP   \n341 [51] and $2 0 - 2 0 0$ for TSPTW [10]), scaling is a challenge, mainly due to the ‘fully-connected’ $O ( n ^ { 2 } )$   \n342 graph neural network. Future work could reduce this complexity following e.g. [33]. The dependency   \n343 on example solutions from an existing solver also becomes more prominent for larger instances,   \n344 but could potentially be removed by ‘bootstrapping’ using DP itself as we, in some sense, have   \n345 done for TSPTW (see Section 3.3). Future work could iterate this process to train the model ‘tabula   \n346 rasa’ (without example solutions), where DP could be seen analogous to MCTS in AlphaZero [48].   \n347 Lastly, the heat $^ +$ potential score function is a well-motivated but heuristic function that was manually   \n348 designed as a function of the predicted heatmap. While it worked well for the three problems we   \n349 considered, it may need suitable adaption for other problems. Training this function end-to-end   \n350 [11, 58], while keeping a low computational footprint, would be an interesting topic for future work. ",
+        "bbox": [
+            147,
+            661,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Luca Accorsi and Daniele Vigo. A fast and scalable heuristic for the solution of large-scale capacitated vehicle routing problems. Technical report, Tech. rep., University of Bologna, 2020.   \n[2] David Applegate, Robert Bixby, Vasek Chvatal, and William Cook. Concorde TSP solver, 2006.   \n[3] Richard Bellman. On the theory of dynamic programming. Proceedings of the National Academy of Sciences of the United States of America, 38(8):716, 1952.   \n[4] Richard Bellman. Dynamic programming treatment of the travelling salesman problem. Journal of the ACM (JACM), 9(1):61–63, 1962.   \n[5] Irwan Bello, Hieu Pham, Quoc V Le, Mohammad Norouzi, and Samy Bengio. Neural combinatorial optimization with reinforcement learning. arXiv preprint arXiv:1611.09940, 2016.   \n[6] Quentin Cappart, Thierry Moisan, Louis-Martin Rousseau, Isabeau Prémont-Schwarz, and Andre Cire. Combining reinforcement learning and constraint programming for combinatorial optimization. arXiv preprint arXiv:2006.01610, 2020.   \n[7] Xinyun Chen and Yuandong Tian. Learning to perform local rewriting for combinatorial optimization. In Advances in Neural Information Processing Systems, volume 32, pages 6281–6292, 2019.   \n[8] William Cook and Paul Seymour. Tour merging via branch-decomposition. INFORMS Journal on Computing, 15(3):233–248, 2003.   \n[9] Paulo Roberto de O da Costa, Jason Rhuggenaath, Yingqian Zhang, and Alp Akcay. Learning 2- opt heuristics for the traveling salesman problem via deep reinforcement learning. Proceedings of Machine Learning Research, 1:17, 2020.   \n[10] Rodrigo Ferreira Da Silva and Sebastián Urrutia. A general vns heuristic for the traveling salesman problem with time windows. Discrete Optimization, 7(4):203–211, 2010.   \n[11] Hal Daumé III and Daniel Marcu. Learning as search optimization: Approximate large margin methods for structured prediction. In Proceedings of the 22nd international conference on Machine learning, pages 169–176, 2005.   \n[12] Arthur Delarue, Ross Anderson, and Christian Tjandraatmadja. Reinforcement learning with combinatorial actions: An application to vehicle routing. Advances in Neural Information Processing Systems, 33, 2020.   \n[13] Michel Deudon, Pierre Cournut, Alexandre Lacoste, Yossiri Adulyasak, and Louis-Martin Rousseau. Learning heuristics for the TSP by policy gradient. In International Conference on the Integration of Constraint Programming, Artificial Intelligence, and Operations Research, pages 170–181. Springer, 2018.   \n[14] Edsger W Dijkstra. A note on two problems in connexion with graphs. Numerische mathematik, 1(1):269–271, 1959.   \n[15] Yvan Dumas, Jacques Desrosiers, Eric Gelinas, and Marius M Solomon. An optimal algorithm for the traveling salesman problem with time windows. Operations research, 43(2):367–371, 1995.   \n[16] Jonas K Falkner and Lars Schmidt-Thieme. Learning to solve vehicle routing problems with time windows through joint attention. arXiv preprint arXiv:2006.09100, 2020.   \n[17] Zhang-Hua Fu, Kai-Bin Qiu, and Hongyuan Zha. Generalize a small pre-trained model to arbitrarily large tsp instances. arXiv preprint arXiv:2012.10658, 2020.   \n[18] Lei Gao, Mingxiang Chen, Qichang Chen, Ganzhong Luo, Nuoyi Zhu, and Zhixin Liu. Learn to design the heuristics for vehicle routing problem. arXiv preprint arXiv:2002.08539, 2020.   \n[19] Maxime Gasse, Didier Chetelat, Nicola Ferroni, Laurent Charlin, and Andrea Lodi. Exact combinatorial optimization with graph convolutional neural networks. In Advances in Neural Information Processing Systems. [20] Joaquim Gromicho, Jelke J van Hoorn, Adrianus Leendert Kok, and Johannes MJ Schutten. Restricted dynamic programming: a flexible framework for solving realistic vrps. Computers & operations research, 39(5):902–909, 2012.   \n01 [21] Joaquim AS Gromicho, Jelke J Van Hoorn, Francisco Saldanha-da Gama, and Gerrit T Timmer. Solving the job-shop scheduling problem optimally by dynamic programming. Computers & Operations Research, 39(12):2968–2977, 2012.   \n04 [22] Gurobi Optimization, LLC. Gurobi, 2018.   \n05 [23] Michael Held and Richard M Karp. A dynamic programming approach to sequencing problems. Journal of the Society for Industrial and Applied Mathematics, 10(1):196–210, 1962. [24] Keld Helsgaun. An extension of the Lin-Kernighan-Helsgaun TSP solver for constrained traveling salesman and vehicle routing problems: Technical report. 2017. [25] Andr�� Hottung and Kevin Tierney. Neural large neighborhood search for the capacitated vehicle routing problem. arXiv preprint arXiv:1911.09539, 2019. [26] Chaitanya K Joshi, Thomas Laurent, and Xavier Bresson. An efficient graph convolutional network technique for the travelling salesman problem. arXiv preprint arXiv:1906.01227, 2019. [27] Chaitanya K Joshi, Thomas Laurent, and Xavier Bresson. On learning paradigms for the travelling salesman problem. arXiv preprint arXiv:1910.07210, 2019. [28] AL Kok, Elias W Hans, Johannes MJ Schutten, and Willem HM Zijm. A dynamic programming heuristic for vehicle routing with time-dependent travel times and required breaks. Flexible services and manufacturing journal, 22(1-2):83–108, 2010. [29] Wouter Kool, Herke van Hoof, and Max Welling. Attention, learn to solve routing problems! In International Conference on Learning Representations, 2019. [30] Yeong-Dae Kwon, Jinho Choo, Byoungjip Kim, Iljoo Yoon, Youngjune Gwon, and Seungjai Min. Pomo: Policy optimization with multiple optima for reinforcement learning. Advances in Neural Information Processing Systems, 33, 2020.   \n23 [31] Gilbert Laporte. The vehicle routing problem: An overview of exact and approximate algorithms. European journal of operational research, 59(3):345–358, 1992. [32] Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. nature, 521(7553):436, 2015. [33] Juho Lee, Yoonho Lee, Jungtaek Kim, Adam Kosiorek, Seungjin Choi, and Yee Whye Teh. Set transformer: A framework for attention-based permutation-invariant neural networks. In International Conference on Machine Learning, pages 3744–3753. PMLR, 2019. [34] Zhuwen Li, Qifeng Chen, and Vladlen Koltun. Combinatorial optimization with graph convolutional networks and guided tree search. Advances in Neural Information Processing Systems, page 539, 2018.   \n33 [35] Hao Lu, Xingwen Zhang, and Shuang Yang. A learning-based iterative method for solving vehicle routing problems. In International Conference on Learning Representations, 2020. [36] Qiang Ma, Suwen Ge, Danyang He, Darshan Thaker, and Iddo Drori. Combinatorial optimization by graph pointer networks and hierarchical reinforcement learning. arXiv preprint arXiv:1911.04936, 2019. [37] Chryssi Malandraki and Robert B Dial. A restricted dynamic programming heuristic algorithm for the time dependent traveling salesman problem. European Journal of Operational Research, 90(1):45–55, 1996.   \n41 [38] Nina Mazyavkina, Sergey Sviridov, Sergei Ivanov, and Evgeny Burnaev. Reinforcement learning for combinatorial optimization: A survey. arXiv preprint arXiv:2003.03600, 2020.   \n[39] Aristide Mingozzi, Lucio Bianco, and Salvatore Ricciardelli. Dynamic programming strategies for the traveling salesman problem with time window and precedence constraints. Operations research, 45(3):365–377, 1997.   \n[40] Vinod Nair, Sergey Bartunov, Felix Gimeno, Ingrid von Glehn, Pawel Lichocki, Ivan Lobov, Brendan O’Donoghue, Nicolas Sonnerat, Christian Tjandraatmadja, Pengming Wang, et al. Solving mixed integer programs using neural networks. arXiv preprint arXiv:2012.13349, 2020.   \n[41] MohammadReza Nazari, Afshin Oroojlooy, Lawrence Snyder, and Martin Takac. Reinforcement learning for solving the vehicle routing problem. In Advances in Neural Information Processing Systems, pages 9860–9870, 2018.   \n[42] Clara Novoa and Robert Storer. An approximate dynamic programming approach for the vehicle routing problem with stochastic demands. European Journal of Operational Research, 196(2):509–515, 2009.   \n[43] Alex Nowak, Soledad Villar, Afonso S Bandeira, and Joan Bruna. A note on learning algorithms for quadratic assignment with graph neural networks. arXiv preprint arXiv:1706.07450, 2017.   \n[44] Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017.   \n[45] Bo Peng, Jiahai Wang, and Zizhen Zhang. A deep reinforcement learning algorithm using dynamic attention model for vehicle routing problems. In International Symposium on Intelligence Computation and Applications, pages 636–650. Springer, 2019.   \n[46] Stefan Ropke and David Pisinger. An adaptive large neighborhood search heuristic for the pickup and delivery problem with time windows. Transportation science, 40(4):455–472, 2006.   \n[47] Gerhard Schrimpf, Johannes Schneider, Hermann Stamm-Wilbrandt, and Gunter Dueck. Record breaking optimization results using the ruin and recreate principle. Journal of Computational Physics, 159(2):139–171, 2000.   \n[48] David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, et al. A general reinforcement learning algorithm that masters chess, shogi, and go through self-play. Science, 362(6419):1140–1144, 2018.   \n[49] Yuan Sun, Andreas Ernst, Xiaodong Li, and Jake Weiner. Generalization of machine learning for problem reduction: a case study on travelling salesman problems. OR Spectrum, pages 1–27, 2020.   \n[50] Paolo Toth and Daniele Vigo. Vehicle routing: problems, methods, and applications. SIAM, 2014.   \n[51] Eduardo Uchoa, Diego Pecin, Artur Pessoa, Marcus Poggi, Thibaut Vidal, and Anand Subramanian. New benchmark instances for the capacitated vehicle routing problem. European Journal of Operational Research, 257(3):845–858, 2017.   \n[52] Wouter van Heeswijk and Han La Poutré. Approximate dynamic programming with neural networks in linear discrete action spaces. arXiv preprint arXiv:1902.09855, 2019.   \n[53] Jelke J. van Hoorn. Dynamic Programming for Routing and Scheduling. PhD thesis, 2016.   \n[54] Natalia Vesselinova, Rebecca Steinert, Daniel F Perez-Ramirez, and Magnus Boman. Learning combinatorial optimization on graphs: A survey with applications to networking. IEEE Access, 8:120388–120416, 2020.   \n[55] Thibaut Vidal. Hybrid genetic search for the cvrp: Open-source implementation and swap\\* neighborhood. arXiv preprint arXiv:2012.10384, 2020.   \n[56] Thibaut Vidal, Teodor Gabriel Crainic, Michel Gendreau, Nadia Lahrichi, and Walter Rei. A hybrid genetic algorithm for multidepot and periodic vehicle routing problems. Operations Research, 60(3):611–624, 2012.   \n[57] Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, pages 2692–2700, 2015.   \n[58] Sam Wiseman and Alexander M Rush. Sequence-to-sequence learning as beam-search optimization. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pages 1296–1306, 2016.   \n[59] Yaoxin Wu, Wen Song, Zhiguang Cao, Jie Zhang, and Andrew Lim. Learning improvement heuristics for solving routing problems. arXiv preprint arXiv:1912.05784, 2019.   \n[60] Liang Xin, Wen Song, Zhiguang Cao, and Jie Zhang. Step-wise deep learning models for solving routing problems. IEEE Transactions on Industrial Informatics, 2020.   \n[61] Shenghe Xu, Shivendra S Panwar, Murali Kodialam, and TV Lakshman. Deep neural network approximated dynamic programming for combinatorial optimization. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 1684–1691, 2020.   \n[62] Feidiao Yang, Tiancheng Jin, Tie-Yan Liu, Xiaoming Sun, and Jialin Zhang. Boosting dynamic programming with neural networks for solving np-hard problems. In Asian Conference on Machine Learning, pages 726–739. PMLR, 2018. ",
+        "bbox": [
+            165,
+            26,
+            826,
+            917
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            153,
+            83,
+            830,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            161,
+            66,
+            828,
+            916
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            158,
+            88,
+            828,
+            349
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            130
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] Scaling and scoring policy, see discussion   \n(c) Did you discuss any potential negative societal impacts of your work? [No] We do not see any issues   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            252
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            257,
+            493,
+            271
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] For claim that DPDP is asymptotically optimal, the DP description defines the set of assumptions and we note the beam size for which this holds.   \n(b) Did you include complete proofs of all theoretical results? [No] Optimality and complexity of full DP for TSP is already known [23, 4] (we do not claim this is a new result, we just mention it) ",
+        "bbox": [
+            238,
+            275,
+            825,
+            361
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            366,
+            393,
+            380
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] Code will be available upon release   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We did a fair job to include all the information necessary to reproduce the experiments   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] For training the model, we used a standard supervised learning setup and we found training to be stable across different problems and data distributions. Due to high computational costs, we did not do multiple runs, which we consider conservative as likely results can be improved by further experiments and training with multiple seeds. As for evaluation of the algorithms on random instances, we use a large test set of 10.000 instances. As we use the same instances for our own implemented baselines, the statistical significance in such a ‘paired’ setting is much higher than would be suggested by error bars. For results directly reported from other papers, the margin is large enough with 10000 instances or we avoid strong claims. With our code, we plan to release all solutions for all test instances for the methods we evaluated ourselves.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] While not explicitly, the total computational requirement for generating training data, which requires the most compute, can be derived from solving 1M instances and the time reported for solving 10K instances in Table 1. This is a number of days (around 4) on a cluster with 10 32-core machines, per problem. ",
+        "bbox": [
+            236,
+            382,
+            825,
+            722
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            215,
+            727,
+            823,
+            742
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [No] This can be found in the original repositories   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] Will be provided with the released code as URL   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No] Data is public or provided in personal communication, consent for publication was given   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            744,
+            825,
+            892
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            897,
+            705,
+            911
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "560 (a) Did you include the full text of instructions given to participants and screenshots, if   \n561 applicable? [N/A]   \n562 (b) Did you describe any potential participant risks, with links to Institutional Review   \n563 Board (IRB) approvals, if applicable? [N/A]   \n564 (c) Did you include the estimated hourly wage paid to participants and the total amount   \n565 spent on participant compensation? [N/A] ",
+        "bbox": [
+            137,
+            90,
+            826,
+            181
+        ],
+        "page_idx": 14
+    }
+]

parse/train/OG18MI5TRL/OG18MI5TRL.md

@@ -0,0 +1,315 @@
+# SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers
+
+nze Xie1 Wenhai Wang2 Zhiding $\mathbf { Y } \mathbf { u } ^ { 3 * }$ Anima Anandkumar3,4 Jose M. Alvarez3 Ping Luo1 1The University of Hong Kong 2Nanjing University 3NVIDIA 4Caltech
+
+xieenze@hku.hk, wangwenhai362@163.com, {zhidingy,josea,aanandkumar}@nvidia.com, pluo@cs.hku.hk
+
+# Abstract
+
+We present SegFormer, a simple, efficient yet powerful semantic segmentation framework which unifies Transformers with lightweight multilayer perceptron (MLP) decoders. SegFormer has two appealing features: 1) SegFormer comprises a novel hierarchically structured Transformer encoder which outputs multiscale features. It does not need positional encoding, thereby avoiding the interpolation of positional codes which leads to decreased performance when the testing resolution differs from training. 2) SegFormer avoids complex decoders. The proposed MLP decoder aggregates information from different layers, and thus combining both local attention and global attention to render powerful representations. We show that this simple and lightweight design is the key to efficient segmentation on Transformers. We scale our approach up to obtain a series of models from SegFormer-B0 to SegFormer-B5, reaching significantly better performance and efficiency than previous counterparts. For example, SegFormer-B4 achieves $5 0 . 3 \%$ mIoU on ADE20K with 64M parameters, being $5 \times$ smaller and $2 . 2 \%$ better than the previous best method. Our best model, SegFormer-B5, achieves $8 4 . 0 \%$ mIoU on Cityscapes validation set and shows excellent zero-shot robustness on Cityscapes-C. Code is available at: github.com/NVlabs/SegFormer.
+
+# 1 Introduction
+
+Semantic segmentation is a fundamental task in computer vision and enables many downstream applications. It is related to image classification since it produces per-pixel category prediction instead of image-level prediction. This relationship is pointed out and systematically studied in a seminal work [1], where the authors used fully convolutional networks (FCNs) for semantic segmentation tasks. Since then, FCN has inspired many follow-up works and has become a predominant design choice for dense prediction.
+
+Since there is a strong relation between classification and semantic segmentation, many stateof-the-art semantic segmentation frameworks are variants of popular architectures for image classification on ImageNet. Therefore, designing backbone architectures has remained an active area
+
+![](images/5007e085fb335dab4808d5eafa6f0f84083b9738fa10bc625833f861e039486b.jpg)  
+Figure 1: Performance vs. model efficiency on ADE20K. SegFormer achieves a new state-of-the-art $5 1 . 0 \%$ mIoU while being significantly more efficient than previous methods.
+
+in semantic segmentation. Indeed, starting from early methods using VGGs [1, 2], to the latest methods with significantly deeper and more powerful backbones [3], the evolution of backbones has dramatically pushed the performance boundary of semantic segmentation. Besides backbone architectures, another line of work formulates semantic segmentation as a structured prediction problem, and focuses on designing modules and operators, which can effectively capture contextual information. A representative example in this area is dilated convolution [4, 5], which increases the receptive field by “inflating” the kernel with holes.
+
+Witnessing the great success in natural language processing (NLP), there has been a recent surge of interest to introduce Transformers to vision tasks. Dosovitskiy et al. [6] proposed vision Transformer (ViT) for image classification. Following the Transformer design in NLP, the authors split an image into multiple linearly embedded patches and feed them into a standard Transformer with positional embeddings (PE), leading to an impressive performance on ImageNet. In semantic segmentation, Zheng et al. [7] proposed SETR to demonstrate the feasibility of using Transformers in this task.
+
+SETR adopts ViT as a backbone and incorporates several CNN decoders to enlarge feature resolution. Despite the good performance, ViT has two important limitations: 1) ViT outputs single-scale lowresolution features instead of multi-scale ones, and 2) it has very high computational cost on large images. To address these limitations, Wang et al. [8] proposed a pyramid vision Transformer (PVT), a natural extension of ViT with pyramid structures for dense prediction. PVT shows considerable improvements over the ResNet counterpart on object detection and semantic segmentation. However, together with other emerging methods such as Swin Transformer [9] and Twins [10], these methods mainly consider the design of the Transformer encoder, neglecting the contribution of the decoder for further improvements.
+
+This paper introduces SegFormer, a cutting-edge Transformer framework for semantic segmentation that jointly considers efficiency, accuracy, and robustness. In contrast to previous methods, our framework redesigns both the encoder and the decoder. The key novelties of our approach are:
+
+• A novel positional-encoding-free and hierarchical Transformer encoder.   
+• A lightweight All-MLP decoder design that yields a powerful representation without complex and computationally demanding modules.   
+• As shown in Figure 1, SegFormer sets new a state-of-the-art in terms of efficiency, accuracy and robustness in three publicly available semantic segmentation datasets.
+
+First, the proposed encoder avoids interpolating positional codes when performing inference on images with resolutions different from the training one. As a result, our encoder can easily adapt to arbitrary test resolutions without impacting the performance. In addition, the hierarchical part enables the encoder to generate both high-resolution fine features and low-resolution coarse features, this is in contrast to ViT that can only produce single low-resolution feature maps with fixed resolutions. Second, we propose a lightweight MLP decoder where the key idea is to take advantage of the Transformer-induced features where the attentions of lower layers tend to stay local, whereas the ones of the highest layers are highly non-local. By aggregating the information from different layers, the MLP decoder combines both local and global attention. As a result, we obtain a simple and straightforward decoder that renders powerful representations.
+
+We demonstrate the advantages of SegFormer in terms of model size, run-time, and accuracy on three publicly available datasets: ADE20K, Cityscapes, and COCO-Stuff. On Citysapces, our lightweight model, SegFormer-B0, without accelerated implementations such as TensorRT, yields $7 1 . 9 \%$ mIoU at 48 FPS, which, compared to ICNet [11], represents a relative improvement of $60 \%$ and $4 . 2 \%$ i n latency and performance, respectively. Our largest model, SegFormer-B5, yields $8 4 . 0 \%$ mIoU, which represents a relative $1 . 8 \%$ mIoU improvement while being $5 \times$ faster than SETR [7]. On ADE20K, this model sets a new state-of-the-art of $5 1 . 8 \%$ mIoU while being $4 \times$ smaller than SETR. Moreover, our approach is significantly more robust to common corruptions and perturbations than existing methods, therefore being suitable for safety-critical applications. Code will be publicly available.
+
+![](images/4ff2abbdc57e6a2df1d3d69c5bae5df978345483cbe78a959ab4764aa8704413.jpg)  
+Figure 2: The proposed SegFormer framework consists of two main modules: A hierarchical Transformer encoder to extract coarse and fine features; and a lightweight All-MLP decoder to directly fuse these multi-level features and predict the semantic segmentation mask. “FFN” indicates feed-forward network.
+
+# 2 Related Work
+
+Semantic Segmentation. Semantic segmentation can be seen as an extension of image classification from image level to pixel level. In the deep learning era [12–14], FCN [1] is the fundamental work of semantic segmentation, which is a fully convolution network that performs pixel-to-pixel classification in an end-to-end manner. After that, researchers focused on improving FCN from different aspects such as: enlarging the receptive field [15–17, 5, 2, 4, 18]; refining the contextual information [19– 27]; introducing boundary information [28–35]; designing various attention modules [36–44]; or using AutoML technologies [45–49]. These methods significantly improve semantic segmentation performance at the expense of introducing many empirical modules, making the resulting framework computationally demanding and complicated. More recent methods have proved the effectiveness of Transformer-based architectures for semantic segmentation [7, 44]. However, these methods are still computationally demanding.
+
+Transformer backbones. ViT [6] is the first work to prove that a pure Transformer can achieve state-of-the-art performance in image classification. ViT treats each image as a sequence of tokens and then feeds them to multiple Transformer layers to make the classification. Subsequently, DeiT [50] further explores a data-efficient training strategy and a distillation approach for ViT. More recent methods such as T2T ViT [51], CPVT [52], TNT [53], CrossViT [54] and LocalViT [55] introduce tailored changes to ViT to further improve image classification performance.
+
+Beyond classification, PVT [8] is the first work to introduce a pyramid structure in Transformer, demonstrating the potential of a pure Transformer backbone compared to CNN counterparts in dense prediction tasks. After that, methods such as Swin [9], CvT [56], CoaT [57], LeViT [58] and Twins [10] enhance the local continuity of features and remove fixed size position embedding to improve the performance of Transformers in dense prediction tasks.
+
+Transformers for specific tasks. DETR [50] is the first to use Transformers for end-to-end object detection framework without non-maximum suppression (NMS). Other works have also used Transformers in tasks such as tracking [59, 60], super-resolution [61], re-id [62], colorization [63], retrieval [64] and multi-modal learning [65, 66]. For semantic segmentation, SETR [7] adopts ViT [6] as a backbone to extract features, achieving impressive performance. However, these Transformer-based methods have very low efficiency and, thus, difficult to deploy in real-time applications.
+
+# 3 Method
+
+As depicted in Figure 2, SegFormer consists of two main modules: (1) a hierarchical Transformer encoder; and (2) a lightweight All-MLP decoder to predict the final mask. Given an image with size $H \times W \times 3$ , we first divide it into patches of size $4 \times 4$ . Unlike ViT which uses $1 6 \times 1 6$ , using fine-grained patches favors semantic segmentation. Second, we use these patches as input to the hierarchical Transformer encoder to get multi-level features with resolution {1/4, 1/8, 1/16, 1/32} of the original image. We then pass these multi-level features to the All-MLP decoder to predict the segmentation mask with a $\begin{array} { r } { \frac { H } { 4 } \times \frac { W } { 4 } \times N _ { c l s } } \end{array}$ resolution, where $N _ { c l s }$ is the number of categories. In the remainder of this section, we first detail the proposed encoder and decoder designs and then summarize the main differences of our approach compared to SETR.
+
+# 3.1 Hierarchical Transformer Encoder
+
+We design a series of Mix Transformer encoders (MiT), MiT-B0 to MiT-B5, with the same architecture but different sizes. On top of the hierarchical architecture and efficient self-attention module in PVT [8], we further propose several novel features including overlapped patch merging and positional-encoding-free design which will be shown to greatly benefit the segmentation tasks.
+
+Hierarchical Feature Representation. Unlike ViT [6], our encoder generates multi-level multi-scale features given an input image. These features provide both high-resolution coarse features and lowresolution fine-grained features that boost the performance of semantic segmentation. Specifically, givemap n input image with siwith a resolution of $H \times W \times 3$ perform, where to o, and a hierarchical fis larger than ure  . $F _ { i }$ $\begin{array} { r } { \frac { H } { 2 ^ { i + 1 } } \times \frac { W } { 2 ^ { i + 1 } } \times C _ { i } } \end{array}$ $i \in \{ 1 , 2 , 3 , 4 \}$ $C _ { i + 1 }$ $C _ { i }$
+
+Efficient Self-Attention. A major bottleneck of the above hierarchical feature representation is the quadratic self-attention complexity with long sequence inputs from higher resolution features. Recall that in the original multi-head self-attention, each of the heads $Q , K , V$ have the same dimensions $N \times C$ , where $N = H \times W$ is the length of the sequence, the self-attention is estimated as:
+
+$$
+\mathrm { A t t e n t i o n } ( Q , K , V ) = \mathrm { S o f t m a x } ( \frac { Q K ^ { \mathsf { T } } } { \sqrt { d _ { h e a d } } } ) V .
+$$
+
+We instead adopt the sequence reduction process introduced in [8]. This process uses a reduction ratio $R$ to reduce the length of the sequence of as follows:
+
+$$
+\begin{array} { l } { { \displaystyle \hat { K } = \mathrm { R e s h a p e } ( \frac { N } { R } , C \cdot R ) ( K ) } } \\ { { \displaystyle K = \mathrm { L i n e a r } ( C \cdot R , C ) ( \hat { K } ) , } } \end{array}
+$$
+
+where $K$ is the sequence to be reduced, Reshape $\begin{array} { r } { \big ( \frac { N } { R } , C \cdot R ) ( K ) } \end{array}$ refers to reshape $K$ to the one with shape of NR $\begin{array} { r } { \frac { N } { R } \times ( C \cdot R ) } \end{array}$ , and Linear $( C _ { i n } , C _ { o u t } ) ( \cdot )$ refers to a linear layer taking a $C _ { i n }$ -dimensional tensor as input and generating a $C _ { o u t }$ -dimensional tensor as output. Therefore, the new $K$ has dimensions $\begin{array} { r } { \frac { N } { R } \times C } \end{array}$ . As a result, the complexity of the self-attention mechanism is reduced from $O ( N ^ { 2 } )$ to $O ( \textstyle { \frac { N ^ { 2 } } { R } } )$ . In our experiments, we set $R$ to [64, 16, 4, 1] from stage-1 to stage-4.
+
+Overlapped Patch Merging. Given an image patch, the patch merging process used in ViT, unifies a $N \times N \times 3$ patch into a $1 \times 1 \times C$ vector. This can easily be extended to unify a $2 \times 2 \times C _ { i }$ feature path into a $1 \times 1 \times C _ { i + 1 }$ vector to obtain hierarchical feature maps. Using this, we can shrink our hierarchical features from other feature map in the hierar $F _ { 1 }$ . $\begin{array} { r } { \frac { H } { 4 } \times \frac { W } { 4 } \times C _ { 1 } ) } \end{array}$ to s i $F _ { 2 }$ a $\begin{array} { r } { ( \frac { H } { 8 } \times \frac { W } { 8 } \times C _ { 2 } ) } \end{array}$ , and then iterate for anycombine non-overlapping image or feature patches. Therefore, it fails to preserve the local continuity around those patches. Instead, we use an overlapping patch merging process. To this end, we define $K , S ,$ , and $P$ , where $K$ is the patch size, $S$ is the stride between two adjacent patches, and $P$ is the padding size. In our experiments, we set $K = 7$ , $S = 4$ , $P = 3$ ,and $K = 3$ , $S = 2$ , $P = 1$ to perform overlapping patch merging to produces features with the same size as the non-overlapping process. Similar to the original patch embedding in ViT [6], this operation can be implemented by “nn.Conv2D” in PyTorch.
+
+Positional-Encoding-Free Design. The resolution of the PE in ViT is fixed. One thus needs to interpolate the PE when the test resolution differs from training. This leads to the drop of accuracy, which is undesirable since the resolution mismatch is common in semantic segmentation. We instead introduce Mix-FFN where we consider the effect of zero padding to the leak location information [67] by directly using a $3 \times 3$ Conv in the feed-forward network (FFN). Mix-FFN is formulated as:
+
+$$
+\begin{array} { r } { { \bf x } _ { o u t } = \bf M L P ( \mathrm { G E L U } ( \mathrm { C o n v } _ { 3 \times 3 } ( \mathbf { M L P } ( \mathbf { x } _ { i n } ) ) ) ) + x _ { i n } , } \end{array}
+$$
+
+where ${ \bf x } _ { i n }$ is the feature from the self-attention module. Mix-FFN mixes a $3 \times 3$ convolution and an MLP into each FFN. In our experiments, we will show that a $3 \times 3$ convolution is sufficient to provide positional information for Transformers. In particular, we use depth-wise convolutions for reducing the number of parameters and improving efficiency.
+
+It should be mentioned that CPVT [52] also alleviates this issue by using a $3 \times 3$ Conv to generate conditional PE at different resolutions and then add it to the feature map. Our work conceptually goes one step further as we argue that adding PE to feature map is not necessary in semantic segmentation. Another recent work CvT [56] introduced $3 \times 3$ Convs to model the spatial relationship among tokens. Despite the converging design, our work differs in both motivation and application as we aim to totally remove PEs to handle the training/testing resolution mismatch issue in semantic segmentation. Our intuition started from [67] whereas the same intuition was not discussed in CvT.
+
+# 3.2 Lightweight All-MLP Decoder
+
+SegFormer incorporates a lightweight decoder consisting only of MLP layers and this avoiding the hand-crafted and computationally demanding components typically used in other methods. The key to enabling such a simple decoder is that our hierarchical Transformer encoder has a larger effective receptive field (ERF) than traditional CNN encoders.
+
+The proposed All-MLP decoder consists of four main steps. First, multi-level features $F _ { i }$ from the MiT encoder go through an MLP layer to unify the channel dimension. Then, in a second step, features are up-sampled to 1/4th and concatenated together. Third, a MLP layer is adopted to fuse the concatenated features $F$ . Finally, another MLP layer takes the fused feature to predict the segmentation mask $M$ with a $\begin{array} { r } { \frac { H } { 4 } \times \frac { W } { 4 } \times N _ { c l s } } \end{array}$ resolution, where $N _ { c l s }$ is the number of categories. This lets us formulate the decoder as:
+
+$$
+\begin{array} { r l } & { \hat { F } _ { i } = \mathrm { L i n e a r } ( C _ { i } , C ) ( F _ { i } ) , \forall i } \\ & { \hat { F } _ { i } = \mathrm { U p s a m p l e } ( \cfrac { W } { 4 } \times \cfrac { W } { 4 } ) ( \hat { F } _ { i } ) , \forall i } \\ & { F = \mathrm { L i n e a r } ( 4 C , C ) ( \mathrm { C o n c a t } ( \hat { F } _ { i } ) ) , \forall i } \\ & { M = \mathrm { L i n e a r } ( C , N _ { c l s } ) ( F ) , } \end{array}
+$$
+
+where M refers to the predicted mask, and Linear $( C _ { i n } , C _ { o u t } ) ( \cdot )$ refers to a linear layer with $C _ { i n }$ and $C _ { o u t }$ as input and output vector dimensions respectively.
+
+Effective Receptive Field Analysis. For semantic segmentation, maintaining large receptive field to include context information has been a central issue [5, 17, 18]. Here, we use effective receptive field (ERF) [68] as a toolkit to visualize and interpret why our MLP decoder design is so effective on Transformers. In Figure 3, we visualize ERFs of the four encoder stages and the decoder heads for both DeepLabv $^ { 3 + }$ and SegFormer. We can make the following observations:
+
+![](images/da07201f1be04852378cd87d5b5e091969253bcbfea5e17953f5e74b2a931d7b.jpg)  
+Figure 3: Effective Receptive Field (ERF) on Cityscapes (average over 100 images). Top row: Deeplabv $^ { 3 + }$ . Bottom row: SegFormer. ERFs of the four stages and the decoder heads of both architectures are visualized. Best viewed with zoom in.
+
+• The ERF of DeepLabv $^ { 3 + }$ is relatively small even at Stage-4, the deepest stage. • SegFormer’s encoder naturally produces local attentions which resemble convolutions at lower stages, while able to output highly non-local attentions that effectively capture contexts at Stage-4. • As shown with the zoom-in patches in Figure 3, the ERF of the MLP head (blue box) differs from Stage-4 (red box) with a significant stronger local attention besides the non-local attention.
+
+The limited receptive field in CNN requires one to resort to context modules such as ASPP [16] that enlarge the receptive field but inevitably become heavy. Our decoder design benefits from the non-local attention in Transformers and leads to a larger receptive field without being complex. The same decoder design, however, does not work well on CNN backbones since the overall receptive field is upper bounded by the limited one at Stage-4, and we will verify this later in Table 1d,
+
+More importantly, our decoder design essentially takes advantage of a Transformer induced feature that produces both highly local and non-local attention at the same time. By unifying them, our MLP decoder renders complementary and powerful representations by adding few parameters. This is another key reason that motivated our design. Taking the non-local attention from Stage-4 alone is not enough to produce good results, as will be verified in Table 1d.
+
+# 3.3 Relationship to SETR.
+
+SegFormer contains multiple more efficient and powerful designs compared with SETR [7]:
+
+• We only use ImageNet-1K for pre-training. ViT in SETR is pre-trained on larger ImageNet-22K.   
+• SegFormer’s encoder has a hierarchical architecture, which is smaller than ViT and can capture both high-resolution coarse and low-resolution fine features. In contrast, SETR’s ViT encoder can only generate single low-resolution feature map.   
+• We remove Positional Embedding in encoder, while SETR uses fixed shape Positional Embedding which decreases the accuracy when the resolution at inference differs from the training ones.   
+• Our MLP decoder is more compact and less computationally demanding than the one in SETR. This leads to a negligible computational overhead. In contrast, SETR requires heavy decoders with multiple $3 \times 3$ convolutions.
+
+# 4 Experiments
+
+# 4.1 Experimental Settings
+
+Datasets: We used four public datasets: Cityscapes [69], ADE20K [70], and COCO-Stuff [71]. ADE20K is a dataset covering 150 fine-grained semantic concepts consisting of 20210 images. Cityscapes is a driving dataset for semantic segmentation consisting of 5000 fine-annotated high resolution images with 19 categories. COCO-Stuff covers 172 labels and consists of 164k images: 118k for training, $5 \mathrm { k }$ for validation, $2 0 \mathrm { k }$ for test-dev and $2 0 \mathrm { k }$ for the test-challenge.
+
+Implementation details: We used the mmsegmentation2 codebase and train on a server with 8 Tesla V100. We pre-train the encoder on the Imagenet-1K dataset and randomly initialize the decoder. During training, we applied data augmentation through random resize with ratio 0.5-2.0, random horizontal flipping, and random cropping to $5 1 2 \times 5 1 2$ , $1 0 2 4 \times 1 0 2 4$ , $5 1 2 \times 5 1 2$ for ADE20K, Cityscapes and COCO-Stuff. Following [9] we set crop size to $6 4 0 \times 6 4 0$ on ADE20K for our largest model B5. We trained the models using AdamW optimizer for 160K iterations on ADE20K, Cityscapes, and 80K iterations on COCO-Stuff. Exceptionally, for the ablation studies, we trained the models for 40K iterations. We used a batch size of 16 for ADE20K, COCO-Stuff and a batch size of 8 for Cityscapes. The learning rate was set to an initial value of 0.00006 and then used a “poly” LR schedule with factor 1.0 by default. For simplicity, we did not adopt widely-used tricks such as OHEM, auxiliary losses or class balance loss. During evaluation, we rescale the short side of the image to training cropping size and keep the aspect ratio for ADE20K and COCO-Stuff. For Cityscapes, we do inference using sliding window test by cropping $1 0 2 4 \times 1 0 2 4$ windows. We report semantic segmentation performance using mean Intersection over Union (mIoU).
+
+# 4.2 Ablation Studies
+
+Influence of the size of model. We first analyze the effect of increasing the size of the encoder on the performance and model efficiency. Figure 1 shows the performance vs. model efficiency for ADE20K as a function of the encoder size and, Table 1a summarizes the results for the three datasets. The first thing to observe here is the size of the decoder compared to the encoder. As shown, for the lightweight model, the decoder has only 0.4M parameters. For MiT-B5 encoder, the decoder only takes up to $4 \%$ of the total number of parameters in the model. In terms of performance, we can observe that, overall, increasing the size of the encoder yields consistent improvements on all the datasets. Our lightweight model, SegFormer-B0, is compact and efficient while maintaining a competitive performance, showing that our method is very convenient for real-time applications. On the other hand, our SegFormer-B5, the largest model, achieves state-of-the-art results on all three datasets, showing the potential of our Transformer encoder.
+
+Table 1: Ablation studies related to model size, encoder and decoder design. (a) Accuracy, parameters and flops as a function of the model size on the three datasets. “SS” and “MS” means single/multi-scal   
+
+<table><tr><td rowspan="2">Encoder Model Size</td><td colspan="2">Params</td><td colspan="2">ADE20K</td><td colspan="2">Cityscapes</td><td colspan="2">COCO-Stuff</td></tr><tr><td>Encoder</td><td>Decoder</td><td>Flops</td><td>mIoU(SS/MS) ↑</td><td>Flops↓</td><td>mIoU(SS/MS) ↑</td><td>Flops↓</td><td>mIoU(SS) ↑</td></tr><tr><td>MiT-B0</td><td>3.4</td><td>0.4</td><td>8.4</td><td>37.4 /38.0</td><td>125.5</td><td>76.2 /78.1</td><td>8.4</td><td>35.6</td></tr><tr><td>MiT-B1</td><td>13.1</td><td>0.6</td><td>15.9</td><td>42.2/43.1</td><td>243.7</td><td>78.5 /80.0</td><td>15.9</td><td>40.2</td></tr><tr><td>MiT-B2</td><td>24.2</td><td>3.3</td><td>62.4</td><td>46.5 /47.5</td><td>717.1</td><td>81.0 /82.2</td><td>62.4</td><td>44.6</td></tr><tr><td>MiT-B3</td><td>44.0</td><td>3.3</td><td>79.0</td><td>49.4 / 50.0</td><td>962.9</td><td>81.7 /83.3</td><td>79.0</td><td>45.5</td></tr><tr><td>MiT-B4</td><td>60.8</td><td>3.3</td><td>95.7</td><td>50.3 / 51.1</td><td>1240.6</td><td>82.3 /83.9</td><td>95.7</td><td>46.5</td></tr><tr><td>MiT-B5</td><td>81.4</td><td>3.3</td><td>183.3</td><td>51.0 / 51.8</td><td>1460.4</td><td>82.4/84.0</td><td>111.6</td><td>46.7</td></tr></table>
+
+(b) Accuracy as a function of the MLP dimension $C$ in the decoder on ADE20K.   
+
+<table><tr><td>C</td><td>Flops↓</td><td>Params↓</td><td>mIoU个</td></tr><tr><td>256</td><td>25.7</td><td>24.7</td><td>44.9</td></tr><tr><td>512</td><td>39.8</td><td>25.8</td><td>45.0</td></tr><tr><td>768</td><td>62.4</td><td>27.5</td><td>45.4</td></tr><tr><td>1024</td><td>93.6</td><td>29.6</td><td>45.2</td></tr><tr><td>2048</td><td>304.4</td><td>43.4</td><td>45.6</td></tr></table>
+
+(c) Mix-FFN vs. positional encoding (PE) for different test resolution on Cityscapes.   
+
+<table><tr><td>Inf Res</td><td>Enc Type</td><td>mIoU↑</td></tr><tr><td>768×768</td><td>PE</td><td>77.3</td></tr><tr><td>1024×2048</td><td>PE</td><td>74.0</td></tr><tr><td>768×768</td><td>Mix-FFN</td><td>80.5</td></tr><tr><td>1024×2048</td><td>Mix-FFN</td><td>79.8</td></tr></table>
+
+(d) Accuracy on ADE20K of CNN and Transformer encoder with MLP decoder. “S4” means stage-4 feature.   
+
+<table><tr><td>Encoder</td><td>Flops ↓</td><td>Params ↓</td><td>mIoU↑</td></tr><tr><td>ResNet50 (S1-4)</td><td>69.2</td><td>29.0</td><td>34.7</td></tr><tr><td>ResNet101 (S1-4)</td><td>88.7</td><td>47.9</td><td>38.7</td></tr><tr><td>ResNeXt101 (S1-4)</td><td>127.5</td><td>86.8</td><td>39.8</td></tr><tr><td>MiT-B2 (S4)</td><td>22.3</td><td>24.7</td><td>43.1</td></tr><tr><td>MiT-B2 (S1-4)</td><td>62.4</td><td>27.7</td><td>45.4</td></tr><tr><td>MiT-B3 (S1-4)</td><td>79.0</td><td>47.3</td><td>48.6</td></tr></table>
+
+Table 2: Comparison to state of the art methods on ADE20K and Cityscapes. SegFormer has significant advantages on #Params (M), #Flops, #Speed and #Accuracy. Note that for SegFormer-B0 we scale the short side of image to {1024, 768, 640, 512} to get speed-accuracy tradeoffs.   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">Method</td><td rowspan="2">Encoder</td><td rowspan="2">Params↓</td><td colspan="3">ADE20K</td><td colspan="3">Cityscapes</td></tr><tr><td>Flops↓</td><td>FPS↑</td><td>mIoU↑</td><td>Flops↓</td><td>FPS↑</td><td>mIoU↑</td></tr><tr><td rowspan="9">Pigalr</td><td rowspan="2">FCN[1] ICNet [11]</td><td>MobileNetV2</td><td>9.8</td><td>39.6</td><td>64.4</td><td>19.7</td><td>317.1</td><td>14.2</td><td>61.5</td></tr><tr><td></td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>30.3</td><td>67.7</td></tr><tr><td>PSPNet [15]</td><td>MobileNetV2</td><td>13.7</td><td>52.9</td><td>57.7</td><td>29.6</td><td>423.4</td><td>11.2</td><td>70.2</td></tr><tr><td>DeepLabV3+[18]</td><td>MobileNetV2</td><td>15.4</td><td>69.4</td><td>43.1</td><td>34.0</td><td>555.4</td><td>8.4</td><td>75.2</td></tr><tr><td rowspan="5">SegFormer (Ours)</td><td rowspan="5">MiT-BO</td><td rowspan="5"></td><td>8.4 -</td><td>50.5</td><td>37.4</td><td>125.5</td><td>15.2</td><td>76.2</td></tr><tr><td>3.8</td><td>-</td><td>-</td><td>51.7</td><td>26.3</td><td>75.3</td></tr><tr><td></td><td>-</td><td>-</td><td>31.5</td><td>37.1</td><td>73.7</td></tr><tr><td>-</td><td>-</td><td>1</td><td>17.7</td><td>47.6</td><td>71.9</td></tr><tr><td>68.6</td><td>14.8</td><td>41.4</td><td>2203.3</td><td>1.2</td><td>76.6</td></tr><tr><td rowspan="9">Nnr arrirr</td><td>EncNet [22]</td><td>ResNet-101 ResNet-101</td><td>55.1</td><td>275.7 218.8</td><td>14.9</td><td>44.7</td><td>1748.0</td><td>1.3</td><td>76.9</td></tr><tr><td>PSPNet [15]</td><td>ResNet-101</td><td>68.1</td><td>256.4</td><td>15.3</td><td>44.4</td><td>2048.9</td><td>1.2</td><td>78.5</td></tr><tr><td>CCNet [39]</td><td>ResNet-101</td><td>68.9</td><td>278.4</td><td>14.1</td><td>45.2</td><td>2224.8</td><td>1.0</td><td>80.2</td></tr><tr><td>DeeplabV3+ [18]</td><td>ResNet-101</td><td>62.7</td><td>255.1</td><td>14.1</td><td>44.1</td><td>2032.3</td><td>1.2</td><td>80.9</td></tr><tr><td>OCRNet [21]</td><td>HRNet-W48</td><td>70.5</td><td>164.8</td><td>17.0</td><td>45.6</td><td>1296.8</td><td>4.2</td><td>81.1</td></tr><tr><td>GSCNN [33]</td><td>WideResNet38</td><td>-</td><td>1</td><td>-</td><td>-</td><td>-</td><td>1</td><td>80.8</td></tr><tr><td>Axial-DeepLab [72]</td><td>AxialResNet-XL</td><td></td><td>-</td><td>-</td><td>1</td><td>2446.8</td><td>-</td><td>81.1</td></tr><tr><td>Dynamic Routing [73] Auto-Deeplab [48]</td><td>Dynamic-L33-PSP</td><td></td><td>=</td><td>=</td><td>- 44.0</td><td>270.0</td><td>-</td><td>80.7 80.3</td></tr><tr><td>SETR[7]</td><td>NAS-F48-ASPP</td><td>-</td><td>-</td><td>- 5.4</td><td>50.2</td><td>695.0</td><td>1 0.5</td><td></td></tr><tr><td></td><td>ViT-Large</td><td>318.3</td><td>-</td><td></td><td></td><td></td><td>-</td><td></td><td>82.2</td></tr><tr><td>SegFormer(Ours)</td><td></td><td>MiT-B4</td><td>64.1</td><td>95.7</td><td>15.4</td><td>51.1</td><td>1240.6</td><td>3.0</td><td>83.8</td></tr><tr><td>SegFormer (Ours)</td><td></td><td>MiT-B5</td><td>84.7</td><td>183.3</td><td>9.8</td><td>51.8</td><td>1447.6</td><td>2.5</td><td>84.0</td></tr></table>
+
+Influence of $C$ , the MLP decoder channel dimension. We now analyze the influence of the channel dimension $C$ in the MLP decoder, see Section 3.2. In Table 1b we show performance, flops, and parameters as a function of this dimension. We can observe that setting $C \ : = \ : 2 5 6$ provides a very competitive performance and computational cost. The performance increases as $C$ increases; however, it leads to larger and less efficient models. Interestingly, this performance plateaus for channel dimensions wider than 768. Given these results, we choose $C = 2 5 6$ for our real-time models SegFormer-B0, B1 and $C = 7 6 8$ for the rest.
+
+Mix-FFN vs. Positional Encoder (PE). In this experiment, we analyze the effect of removing the positional encoding in the Transformer encoder in favor of using the proposed Mix-FFN. To this end, we train Transformer encoders with a positional encoding (PE) and the proposed Mix-FFN and perform inference on Cityscapes with two different image resolutions: $7 6 8 \times 7 6 8$ using a sliding window, and $1 0 2 4 \times 2 0 4 8$ using the whole image.
+
+Table 1c shows the results for this experiment. As shown, for a given resolution, our approach using Mix-FFN clearly outperforms using a positional encoding. Moreover, our approach is less sensitive to differences in the test resolution: the accuracy drops $3 . 3 \%$ when using a positional encoding with a lower resolution. In contrast, when we use the proposed Mix-FFN the performance drop is reduced to only $0 . 7 \%$ . From these results, we can conclude using the proposed Mix-FFN produces better and more robust encoders than those using positional encoding.
+
+Effective receptive field evaluation. In Section 3.2, we argued that our MLP decoder benefits from Transformers having a larger effective receptive field compared to other CNN models. To quantify this effect, in this experiment, we compare the performance of our MLP-decoder when used with CNN-based encoders such as ResNet or ResNeXt. As shown in Table 1d, coupling our MLP-decoder with a CNN-based encoder yields a significantly lower accuracy compared to coupling it with the proposed Transformer encoder. Intuitively, as a CNN has a smaller receptive field than the Transformer (see the analysis in Section 3.2), the MLP-decoder is not enough for global reasoning. In contrast, coupling our Transformer encoder with the MLP decoder leads to the best performance. Moreover, for Transformer encoder, it is necessary to combine low-level local features and high-level non-local features instead of only high-level feature.
+
+Influence of difference encoders. We select 2 representative Transformer encoders, ViT [6] and Swin [9] and compare with our MiT encoder. As shown in Table 3, with same decoder, e.g.MLP decoder, MiT-B2 is $3 . 1 \%$ higher than Swin-T with similar encoder parameters. Moreover, MiT-B5 has much fewer encoder parameters than ViT-large, but is $3+ \%$ mIoU higher than ViT-large. These experiments shows our MiT encoder is better than Swin and ViT for semantic segmentataion.
+
+Influence of difference decoders. We also test MiT encoder with different decoders. As shown
+
+Table 3: Ablation study of different Transformer encoders and different decoders. All the model are trained on ADE20K with 160K iterations.   
+
+<table><tr><td>Encoder</td><td>Decoder</td><td>mIoU</td><td>FPS</td><td>Decoder GFlops</td><td>Decoder Params (M)</td></tr><tr><td>MiT-B2</td><td>UperNet (Swin)</td><td>46.5</td><td>14.2</td><td>210.7</td><td>29.7</td></tr><tr><td>MiT-B2</td><td>MLA (SETR)</td><td>46.2</td><td>9.5</td><td>87.7</td><td>4.2</td></tr><tr><td>MiT-B2</td><td>MLP(Ours)</td><td>46.5</td><td>21.4</td><td>42.1</td><td>3.3</td></tr><tr><td>MiT-B5</td><td>UperNet (Swin)</td><td>50.7</td><td>5.3</td><td>210.7</td><td>29.7</td></tr><tr><td>MiT-B5</td><td>MLA (SETR)</td><td>50.9</td><td>3.8</td><td>87.7</td><td>4.2</td></tr><tr><td>MiT-B5</td><td>MLP(Ours)</td><td>51.0</td><td>9.8</td><td>42.1</td><td>3.3</td></tr><tr><td>Swin-T</td><td>MLP(Ours)</td><td>43.4</td><td>20.6</td><td>42.8</td><td>3.6</td></tr><tr><td>Swin-T</td><td>UperNet (Swin)</td><td>44.5</td><td>15.4</td><td>211.3</td><td>31.4</td></tr><tr><td>ViT-L</td><td>MLP(Ours)</td><td>47.7</td><td>4.7</td><td>0.6</td><td>0.6</td></tr><tr><td>ViT-L</td><td>MLA (SETR)</td><td>47.7</td><td>4.6</td><td>1.8</td><td>3.7</td></tr></table>
+
+in Table 3, the mIoUs are similar with different decoders while the proposed MLP decoder has the least parameters and is only $1 / 8$ of the UperNet decoder in Swin. The MLP decoder is thus an important design towards efficient segmentation.
+
+# 4.3 Comparison to state of the art methods
+
+We now compare our results with existing approaches on the ADE20K [70] and Cityscapes [69].   
+More experiments about COCO-Stuff [71] are in appendix.
+
+ADE20K and Cityscapes: Table 2 summarizes our results including parameters, FLOPS, latency, and accuracy for ADE20K and Cityscapes. In the top part of the table, we report real-time approaches where we include state-of-the-art methods and our results using the MiT-B0 lightweight encoder. In the bottom part, we focus on performance and report the results of our approach and related works using stronger encoders.
+
+On ADE20K, SegFormer-B0 yields $3 7 . 4 \%$ mIoU using only $3 . 8 \mathbf { M }$ parameters and 8.4G FLOPs, outperforming all other real-time counterparts in terms of parameters, flops, and latency. For instance, compared to Deeplab ${ \mathrm { V } } 3 +$ (MobileNetV2), SegFormer-B0 is 7.4 FPS, which is faster and keeps $3 . 4 \%$ better mIoU.
+
+Moreover, SegFormer-B5 outperforms all other approaches, including the previous best SETR, and establishes a new state-of-the-art of $5 1 . 8 \%$ , which is $1 . 6 \%$ mIoU better than SETR while being significantly more efficient.
+
+Table 4: Comparison to state of the art methods on Cityscapes test set. IM-1K, IM-22K, Coarse and MV refer to the ImageNet-1K, ImageNet-22K, Cityscapes coarse set and Mapillary Vistas.   
+
+<table><tr><td>Method</td><td>Encoder</td><td>Extra Data</td><td>mIoU</td></tr><tr><td>PSPNet [15]</td><td>ResNet-101</td><td>IM-1K</td><td>78.4</td></tr><tr><td>PSANet [41]</td><td>ResNet-101</td><td>IM-1K</td><td>80.1</td></tr><tr><td>CCNet [39]</td><td>ResNet-101</td><td>IM-1K</td><td>81.9</td></tr><tr><td>OCNet[19]</td><td>ResNet-101</td><td>IM-1K</td><td>80.1</td></tr><tr><td>Axial-DeepLab [72]</td><td>AxiaiResNet-XL</td><td>IM-1K</td><td>79.9</td></tr><tr><td>SETR[7]</td><td>ViT</td><td>IM-22K</td><td>81.0</td></tr><tr><td>SETR [7]</td><td>ViT</td><td>IM-22K,Coarse</td><td>81.6</td></tr><tr><td>SegFormer</td><td>MiT-B5</td><td>IM-1K</td><td>82.2</td></tr><tr><td>SegFormer</td><td>MiT-B5</td><td>IM-1K,MV</td><td>83.1</td></tr></table>
+
+As also shown in Table 2, our results also hold on Cityscapes. SegFormer-B0 yields 15.2 FPS and $7 6 . 2 \%$ mIoU (the shorter side of input image being 1024), which represents a $1 . 3 \%$ mIoU improvement and a $2 \times$ speedup compared to Deeplab ${ \mathrm { V } } 3 +$ . Moreover, with the shorter side of input image being 512, SegFormer-B0 runs at 47.6 FPS and yields $7 1 . 9 \%$ mIoU, which is $1 7 . 3 \mathrm { F P S }$ faster and $4 . 2 \%$ better than ICNet. SegFormer-B5 archives the best IoU of $8 4 . 0 \%$ , outperforming all existing methods by at least $1 . 8 \%$ mIoU, and it runs $5 \times$ faster and $4 \times$ smaller than SETR [7]. On Cityscapes test set, we follow the common setting [18] and merge the validation images to the train set and report results using Imagenet-1K pre-training and also using Mapillary Vistas [74]. As reported in Table 4, using only Cityscapes fine data and Imagenet-1K pre-training, our method achieves $8 2 . 2 \%$ mIoU outperforming all other methods including SETR, which uses ImageNet-22K pre-training and the additional Cityscapes coarse data. Using Mapillary pre-training, our sets a new state-of-the-art result of $8 3 . 1 \%$ mIoU.
+
+# 4.4 Robustness to natural corruptions
+
+Model robustness is important for many safety-critical tasks such as autonomous driving [75]. In this experiment, we evaluate the robustness of SegFormer to common corruptions and perturbations. To this end, we follow [75] and generate Cityscapes-C, which expands the Cityscapes validation set with 16 types of algorithmically generated corruptions from noise, blur, weather and digital categories. We compare our method to Deeplab ${ \mathrm { V } } 3 +$ and other methods as reported in [75]. We also compare with SETR with DeiT Transformer backbone. The results for this experiment are summarized in Table 5.
+
+Our method significantly outperforms previous CNN-based methods, yielding a relative improvement of up to $58 8 \%$ on Gaussian Noise and up to $29 5 \%$ on snow weather. SegFormer also outperforms SETR in general except for one corruption (snow). The results indicate the strong robustness of SegFormer, which we envision to benefit safety-critical applications where robustness is important.
+
+Table 5: Main results on Cityscapes-C. $\mathrm { \Delta } ^ { \circ } \mathrm { D L v } 3 + \mathrm { \Delta } ^ { \circ }$ , “MBv2”, “R” and “X” refer to DeepLabv $^ { 3 + }$ , MobileNetv2, ResNet and Xception. The mIoUs of compared methods are reported from [75].   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Clean</td><td colspan="4">Blur</td><td colspan="4">Noise</td><td colspan="4">Digital</td><td colspan="4">Weather</td></tr><tr><td>Motion Defoc Glass Gauss</td><td></td><td></td><td></td><td>Gauss</td><td>Impul Shot Speck Bright Contr Satur JPEG</td><td></td><td></td><td></td><td></td><td></td><td></td><td>Snow</td><td>Spatt Fog</td><td></td><td>Frost</td></tr><tr><td>DLv3+ (MBv2)</td><td>72.0</td><td>53.5</td><td>49.0</td><td>45.3</td><td>49.1</td><td>6.4</td><td>7.0</td><td>6.6</td><td>16.6</td><td>51.7</td><td>46.7</td><td>32.4</td><td>27.2</td><td>13.7</td><td>38.9</td><td>47.4</td><td>17.3</td></tr><tr><td>DLv3+ (R50)</td><td>76.6</td><td>58.5</td><td>56.6</td><td>47.2</td><td>57.7</td><td>6.5</td><td>7.2</td><td>10.0</td><td>31.1</td><td>58.2</td><td>54.7</td><td>41.3</td><td>27.4</td><td>12.0</td><td>42.0</td><td>）55.9</td><td>22.8</td></tr><tr><td>DLv3+ (R101)</td><td>77.1</td><td>59.1</td><td>56.3</td><td>47.7</td><td>57.3</td><td>13.2</td><td>13.9</td><td>16.3</td><td>36.9</td><td>59.2</td><td>54.5</td><td>41.5</td><td>37.4</td><td>11.9</td><td>47.8</td><td>55.1</td><td>22.7</td></tr><tr><td>DLv3+ (X41)</td><td>77.8</td><td>61.6</td><td>54.9</td><td>51.0</td><td>54.7</td><td>17.0</td><td>17.3</td><td>21.6</td><td>43.7</td><td>63.6</td><td>56.9</td><td>51.7</td><td>38.5</td><td>18.2</td><td>46.6</td><td>57.6</td><td>20.6</td></tr><tr><td>DLv3+ (X65)</td><td>78.4</td><td>63.9</td><td>59.1</td><td>52.8</td><td>59.2</td><td>15.0</td><td>10.6</td><td>19.8</td><td>42.4</td><td>65.9</td><td>59.1</td><td>46.1</td><td>31.4</td><td>19.3</td><td>50.7</td><td>63.6</td><td>23.8</td></tr><tr><td>DLv3+ (X71)</td><td>78.6</td><td>64.1</td><td>60.9</td><td>52.0</td><td>60.4</td><td>14.9</td><td>10.8</td><td>19.4</td><td>41.2</td><td>68.0</td><td>58.7</td><td>47.1</td><td>40.2</td><td>18.8</td><td>50.4</td><td>64.1</td><td>20.2</td></tr><tr><td>ICNet</td><td>65.9</td><td>45.8</td><td>44.6</td><td>47.4</td><td>44.7</td><td>8.4</td><td>8.4</td><td>10.6</td><td>27.9</td><td>41.0</td><td>33.1</td><td>27.5</td><td>34.0</td><td>6.3</td><td>30.5</td><td>27.3</td><td>11.0</td></tr><tr><td>FCN8s</td><td>66.7</td><td>42.7</td><td>31.1</td><td>37.0</td><td>34.1</td><td>6.7</td><td>5.7</td><td>7.8</td><td>24.9</td><td>53.3</td><td>39.0</td><td>36.0</td><td>21.2</td><td>11.3</td><td>31.6</td><td>37.6</td><td>19.7</td></tr><tr><td>DilatedNet</td><td>68.6</td><td>44.4</td><td>36.3</td><td>32.5</td><td>38.4</td><td>15.6</td><td>14.0</td><td>18.4</td><td>32.7</td><td>52.7</td><td>32.6</td><td>38.1</td><td>29.1</td><td>12.5</td><td>32.3</td><td>34.7</td><td>19.2</td></tr><tr><td>ResNet-38</td><td>77.5</td><td>54.6</td><td>45.1</td><td>43.3</td><td>47.2</td><td>13.7</td><td>16.0</td><td>18.2</td><td>38.3</td><td>60.0</td><td>50.6</td><td>46.9</td><td>14.7</td><td>13.5</td><td>45.9</td><td>52.9</td><td>22.2</td></tr><tr><td>PSPNet</td><td>78.8</td><td>59.8</td><td>53.2</td><td>44.4</td><td>53.9</td><td>11.0</td><td>15.4</td><td>15.4</td><td>34.2</td><td>60.4</td><td>51.8</td><td>30.6</td><td>21.4</td><td>8.4</td><td>42.7</td><td>34.4</td><td>16.2</td></tr><tr><td>GSCNN</td><td>80.9</td><td>58.9</td><td>58.4</td><td>41.9</td><td>60.1</td><td>5.5</td><td>2.6</td><td>6.8</td><td>24.7</td><td>75.9</td><td>61.9</td><td>70.7</td><td>12.0</td><td>12.4</td><td>47.3</td><td>67.9</td><td>32.6</td></tr><tr><td>SETR-DeiT</td><td>78.9</td><td>64.9</td><td>65.1</td><td>59.1</td><td>65.3</td><td>54.7</td><td>60.5</td><td>51.9</td><td>69.4</td><td>74.9</td><td>69.6</td><td>74.9</td><td>58.5</td><td>44.3</td><td>64.8</td><td>68.2</td><td>39.1</td></tr><tr><td>SegFormer-B5</td><td>82.4</td><td>69.1</td><td>68.6</td><td>64.1</td><td>69.8</td><td>57.8</td><td>63.4</td><td>52.3</td><td>72.8</td><td>81.0</td><td>77.7</td><td>80.1</td><td>58.8</td><td>40.7</td><td>68.4</td><td>78.5</td><td>49.9</td></tr></table>
+
+# 5 Conclusion
+
+In this paper, we present SegFormer, a simple, clean yet powerful semantic segmentation method which contains a positional-encoding-free, hierarchical Transformer encoder and a lightweight AllMLP decoder. It avoids common complex designs in previous methods, leading to both high efficiency and performance. SegFormer not only achieves new state of the art results on common datasets, but also shows strong zero-shot robustness. We hope our method can serve as a solid baseline for semantic segmentation and motivate further research. One potential limitation is that even our lightest model may still be too heavy for some edge devices. Thus mixed-precision training, pruning, hardware-friendly attention designs and energy consumption are important parts of our future work.
+
+# Broader Impact
+
+Efficiency, accuracy, and robustness are important aspects of AI models. Our work pushes the boundary of semantic segmentation models in these three aspects. We envision that the work will benefit a wide range of safety-critical applications, such as autonomous driving and robot navigation. The proposed method improves the “in-the-wild” robustness of these applications, ultimately leading to better safety. Despite such improvement, we fully understand this work is by no means perfect and there are still many challenges towards reliable real world application. Our models may be subject to biases and other possible undesired mistakes, depending on how they are trained in reality. Our model may also be used for surveillance similar to other AI recognition methods, even though it is not mainly designed for surveillance applications.
+
+# Acknowledgments and Disclosure of Funding
+
+We thank Ding Liang, Zhe Chen and Yaojun Liu for insightful discussion without which this paper would not be possible. Ping Luo is supported by the General Research Fund of Hong Kong No.27208720.
+
+# References
+
+[1] Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In CVPR, 2015. 1, 2, 3, 7 [2] Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L Yuille. Semantic image segmentation with deep convolutional nets and fully connected CRFs. In ICLR, 2015. 2, 3   
+[3] Hang Zhang, Chongruo Wu, Zhongyue Zhang, Yi Zhu, Haibin Lin, Zhi Zhang, Yue Sun, Tong He, Jonas Mueller, R Manmatha, et al. ResNest: Split-attention networks. arXiv, 2020. 2   
+[4] Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected CRFs. TPAMI, 2017. 2, 3   
+[5] Fisher Yu and Vladlen Koltun. Multi-scale context aggregation by dilated convolutions. In ICLR, 2016. 2, 3, 5   
+[6] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv, 2020. 2, 3, 4, 8   
+[7] Sixiao Zheng, Jiachen Lu, Hengshuang Zhao, Xiatian Zhu, Zekun Luo, Yabiao Wang, Yanwei Fu, Jianfeng Feng, Tao Xiang, Philip HS Torr, et al. Rethinking semantic segmentation from a sequence-to-sequence perspective with transformers. CVPR, 2021. 2, 3, 6, 7, 8, 9   
+[8] Wenhai Wang, Enze Xie, Xiang Li, Deng-Ping Fan, Kaitao Song, Ding Liang, Tong Lu, Ping Luo, and Ling Shao. Pyramid vision transformer: A versatile backbone for dense prediction without convolutions. arXiv, 2021. 2, 3, 4   
+[9] Ze Liu, Yutong Lin, Yue Cao, Han Hu, Yixuan Wei, Zheng Zhang, Stephen Lin, and Baining Guo. Swin transformer: Hierarchical vision transformer using shifted windows. arXiv, 2021. 2, 3, 6, 8   
+[10] Xiangxiang Chu, Zhi Tian, Yuqing Wang, Bo Zhang, Haibing Ren, Xiaolin Wei, Huaxia Xia, and Chunhua Shen. Twins: Revisiting spatial attention design in vision transformers. arXiv, 2021. 2, 3   
+[11] Hengshuang Zhao, Xiaojuan Qi, Xiaoyong Shen, Jianping Shi, and Jiaya Jia. Icnet for real-time semantic segmentation on high-resolution images. In ECCV, 2018. 2, 7   
+[12] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. 3   
+[13] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. NeurIPS, 2012.   
+[14] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv, 2014. 3   
+[15] Hengshuang Zhao, Jianping Shi, Xiaojuan Qi, Xiaogang Wang, and Jiaya Jia. Pyramid scene parsing network. In CVPR, 2017. 3, 7, 8   
+[16] Maoke Yang, Kun Yu, Chi Zhang, Zhiwei Li, and Kuiyuan Yang. Denseaspp for semantic segmentation in street scenes. In CVPR, 2018. 5   
+[17] Chao Peng, Xiangyu Zhang, Gang Yu, Guiming Luo, and Jian Sun. Large kernel matters–improve semantic segmentation by global convolutional network. In CVPR, 2017. 3, 5   
+[18] Liang-Chieh Chen, Yukun Zhu, George Papandreou, Florian Schroff, and Hartwig Adam. Encoder-decoder with atrous separable convolution for semantic image segmentation. In ECCV, 2018. 3, 5, 7, 9   
+[19] Yuhui Yuan and Jingdong Wang. Ocnet: Object context network for scene parsing. arXiv, 2018. 3, 8   
+[20] Changqian Yu, Jingbo Wang, Changxin Gao, Gang Yu, Chunhua Shen, and Nong Sang. Context prior for scene segmentation. In CVPR, 2020.   
+[21] Yuhui Yuan, Xilin Chen, and Jingdong Wang. Object-contextual representations for semantic segmentation. arXiv, 2019. 7   
+[22] Hang Zhang, Kristin Dana, Jianping Shi, Zhongyue Zhang, Xiaogang Wang, Ambrish Tyagi, and Amit Agrawal. Context encoding for semantic segmentation. In CVPR, 2018. 7   
+[23] Yizhou Zhou, Xiaoyan Sun, Zheng-Jun Zha, and Wenjun Zeng. Context-reinforced semantic segmentation. In CVPR, 2019.   
+[24] Guosheng Lin, Anton Milan, Chunhua Shen, and Ian Reid. Refinenet: Multi-path refinement networks for high-resolution semantic segmentation. In CVPR, 2017.   
+[25] Rudra PK Poudel, Ujwal Bonde, Stephan Liwicki, and Christopher Zach. Contextnet: Exploring context and detail for semantic segmentation in real-time. arXiv, 2018.   
+[26] Tianyi Wu, Sheng Tang, Rui Zhang, and Yongdong Zhang. Cgnet: A light-weight context guided network for semantic segmentation. arXiv, 2018.   
+[27] Junjun He, Zhongying Deng, Lei Zhou, Yali Wang, and Yu Qiao. Adaptive pyramid context network for semantic segmentation. In CVPR, 2019. 3   
+[28] Henghui Ding, Xudong Jiang, Ai Qun Liu, Nadia Magnenat Thalmann, and Gang Wang. Boundary-aware feature propagation for scene segmentation. In ICCV, 2019. 3   
+[29] Gedas Bertasius, Jianbo Shi, and Lorenzo Torresani. Semantic segmentation with boundary neural fields. In CVPR, 2016.   
+[30] Xiangtai Li, Xia Li, Li Zhang, Guangliang Cheng, Jianping Shi, Zhouchen Lin, Shaohua Tan, and Yunhai Tong. Improving semantic segmentation via decoupled body and edge supervision. arxiv, 2020.   
+[31] Yuhui Yuan, Jingyi Xie, Xilin Chen, and Jingdong Wang. Segfix: Model-agnostic boundary refinement for segmentation. In ECCV, 2020.   
+[32] Mingmin Zhen, Jinglu Wang, Lei Zhou, Shiwei Li, Tianwei Shen, Jiaxiang Shang, Tian Fang, and Long Quan. Joint semantic segmentation and boundary detection using iterative pyramid contexts. In CVPR, 2020.   
+[33] Towaki Takikawa, David Acuna, Varun Jampani, and Sanja Fidler. Gated-scnn: Gated shape cnns for semantic segmentation. In ICCV, 2019. 7   
+[34] Changqian Yu, Jingbo Wang, Chao Peng, Changxin Gao, Gang Yu, and Nong Sang. Learning a discriminative feature network for semantic segmentation. In CVPR, 2018.   
+[35] Liang-Chieh Chen, Jonathan T Barron, George Papandreou, Kevin Murphy, and Alan L Yuille. Semantic image segmentation with task-specific edge detection using cnns and a discriminatively trained domain transform. In CVPR, 2016. 3   
+[36] Jun Fu, Jing Liu, Haijie Tian, Yong Li, Yongjun Bao, Zhiwei Fang, and Hanqing Lu. Dual attention network for scene segmentation. In CVPR, 2019. 3   
+[37] Xiaolong Wang, Ross Girshick, Abhinav Gupta, and Kaiming He. Non-local neural networks. In CVPR, 2018.   
+[38] Zilong Zhong, Zhong Qiu Lin, Rene Bidart, Xiaodan Hu, Ibrahim Ben Daya, Zhifeng Li, Wei-Shi Zheng, Jonathan Li, and Alexander Wong. Squeeze-and-attention networks for semantic segmentation. In CVPR, 2020.   
+[39] Zilong Huang, Xinggang Wang, Lichao Huang, Chang Huang, Yunchao Wei, and Wenyu Liu. Ccnet: Criss-cross attention for semantic segmentation. In ICCV, 2019. 7, 8   
+[40] Hanchao Li, Pengfei Xiong, Jie An, and Lingxue Wang. Pyramid attention network for semantic segmentation. arXiv, 2018.   
+[41] Hengshuang Zhao, Yi Zhang, Shu Liu, Jianping Shi, Chen Change Loy, Dahua Lin, and Jiaya Jia. Psanet: Point-wise spatial attention network for scene parsing. In ECCV, 2018. 8   
+[42] Xia Li, Zhisheng Zhong, Jianlong Wu, Yibo Yang, Zhouchen Lin, and Hong Liu. Expectation-maximization attention networks for semantic segmentation. In ICCV, 2019.   
+[43] Yue Cao, Jiarui Xu, Stephen Lin, Fangyun Wei, and Han Hu. Gcnet: Non-local networks meet squeezeexcitation networks and beyond. In ICCVW, 2019.   
+[44] Enze Xie, Wenjia Wang, Wenhai Wang, Peize Sun, Hang Xu, Ding Liang, and Ping Luo. Segmenting transparent object in the wild with transformer. IJCAI, 2021. 3   
+[45] Albert Shaw, Daniel Hunter, Forrest Landola, and Sammy Sidhu. Squeezenas: Fast neural architecture search for faster semantic segmentation. In ICCVW, 2019. 3   
+[46] Wuyang Chen, Xinyu Gong, Xianming Liu, Qian Zhang, Yuan Li, and Zhangyang Wang. Fasterseg: Searching for faster real-time semantic segmentation. arXiv, 2019.   
+[47] Yanwei Li, Lin Song, Yukang Chen, Zeming Li, Xiangyu Zhang, Xingang Wang, and Jian Sun. Learning dynamic routing for semantic segmentation. In CVPR, 2020.   
+[48] Chenxi Liu, Liang-Chieh Chen, Florian Schroff, Hartwig Adam, Wei Hua, Alan L Yuille, and Li Fei-Fei. Auto-deeplab: Hierarchical neural architecture search for semantic image segmentation. In CPVR, 2019. 7   
+[49] Vladimir Nekrasov, Hao Chen, Chunhua Shen, and Ian Reid. Fast neural architecture search of compact semantic segmentation models via auxiliary cells. In CVPR, 2019. 3   
+[50] Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and Sergey Zagoruyko. End-to-End object detection with transformers. In ECCV, 2020. 3   
+[51] Li Yuan, Yunpeng Chen, Tao Wang, Weihao Yu, Yujun Shi, Zihang Jiang, Francis EH Tay, Jiashi Feng, and Shuicheng Yan. Tokens-to-token vit: Training vision transformers from scratch on imagenet. arXiv, 2021. 3   
+[52] Xiangxiang Chu, Zhi Tian, Bo Zhang, Xinlong Wang, Xiaolin Wei, Huaxia Xia, and Chunhua Shen. Conditional positional encodings for vision transformers. arXiv, 2021. 3, 5   
+[53] Kai Han, An Xiao, Enhua Wu, Jianyuan Guo, Chunjing Xu, and Yunhe Wang. Transformer in transformer. arXiv, 2021. 3   
+[54] Chun-Fu Chen, Quanfu Fan, and Rameswar Panda. Crossvit: Cross-attention multi-scale vision transformer for image classification. arXiv, 2021. 3   
+[55] Yawei Li, Kai Zhang, Jiezhang Cao, Radu Timofte, and Luc Van Gool. Localvit: Bringing locality to vision transformers. arXiv, 2021. 3   
+[56] Haiping Wu, Bin Xiao, Noel Codella, Mengchen Liu, Xiyang Dai, Lu Yuan, and Lei Zhang. Cvt: Introducing convolutions to vision transformers. arXiv, 2021. 3, 5   
+[57] Weijian Xu, Yifan Xu, Tyler Chang, and Zhuowen Tu. Co-scale conv-attentional image transformers. arXiv, 2021. 3   
+[58] Ben Graham, Alaaeldin El-Nouby, Hugo Touvron, Pierre Stock, Armand Joulin, Hervé Jégou, and Matthijs Douze. Levit: a vision transformer in convnet’s clothing for faster inference. arXiv, 2021. 3   
+[59] Peize Sun, Yi Jiang, Rufeng Zhang, Enze Xie, Jinkun Cao, Xinting Hu, Tao Kong, Zehuan Yuan, Changhu Wang, and Ping Luo. Transtrack: Multiple-object tracking with transformer. arXiv, 2020. 3   
+[60] Tim Meinhardt, Alexander Kirillov, Laura Leal-Taixe, and Christoph Feichtenhofer. Trackformer: Multiobject tracking with transformers. arXiv, 2021. 3   
+[61] Hanting Chen, Yunhe Wang, Tianyu Guo, Chang Xu, Yiping Deng, Zhenhua Liu, Siwei Ma, Chunjing Xu, Chao Xu, and Wen Gao. Pre-trained image processing transformer. arXiv, 2020. 3   
+[62] Shuting He, Hao Luo, Pichao Wang, Fan Wang, Hao Li, and Wei Jiang. Transreid: Transformer-based object re-identification. arXiv, 2021. 3   
+[63] Manoj Kumar, Dirk Weissenborn, and Nal Kalchbrenner. Colorization transformer. arXiv, 2021. 3   
+[64] Alaaeldin El-Nouby, Natalia Neverova, Ivan Laptev, and Hervé Jégou. Training vision transformers for image retrieval. arXiv, 2021. 3   
+[65] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. arXiv, 2021. 3   
+[66] Ronghang Hu and Amanpreet Singh. Transformer is all you need: Multimodal multitask learning with a unified transformer. arXiv, 2021. 3   
+[67] Md Amirul Islam, Sen Jia, and Neil DB Bruce. How much position information do convolutional neural networks encode? arXiv, 2020. 4, 5   
+[68] Wenjie Luo, Yujia Li, Raquel Urtasun, and Richard Zemel. Understanding the effective receptive field in deep convolutional neural networks. arXiv, 2017. 5   
+[69] Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The cityscapes dataset for semantic urban scene understanding. In CVPR, 2016. 6, 8   
+[70] Bolei Zhou, Hang Zhao, Xavier Puig, Sanja Fidler, Adela Barriuso, and Antonio Torralba. Scene parsing through ade20k dataset. In CVPR, 2017. 6, 8   
+[71] Holger Caesar, Jasper Uijlings, and Vittorio Ferrari. Coco-stuff: Thing and stuff classes in context. In CVPR, 2018. 6, 8   
+[72] Huiyu Wang, Yukun Zhu, Bradley Green, Hartwig Adam, Alan L. Yuille, and Liang-Chieh Chen. Axialdeeplab: Stand-alone axial-attention for panoptic segmentation. In ECCV, 2020. 7, 8   
+[73] Yanwei Li, Lin Song, Yukang Chen, Zeming Li, Xiangyu Zhang, Xingang Wang, and Jian Sun. Learning dynamic routing for semantic segmentation. In CVPR, 2020.   
+[74] Gerhard Neuhold, Tobias Ollmann, Samuel Rota Bulò, and Peter Kontschieder. The mapillary vistas dataset for semantic understanding of street scenes. In ICCV, 2017. 9   
+[75] Christoph Kamann and Carsten Rother. Benchmarking the robustness of semantic segmentation models. In CVPR, 2020. 9
+
+# 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] Please Section 5.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] Please see Broader Impact.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] We observed quite stable mIoU results for semantic segmentation models.   
+(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] Please see Section 4.   
+(b) Did you mention the license of the assets? [Yes] The data used in our work is open source and can be used for adademic research.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We provide our code for this work in the supplemental material.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] The data used in our work is open source and can be used for adademic research.   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] The data does not contain personally identifiable information or offensive content.
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/OG18MI5TRL/OG18MI5TRL_content_list.json

@@ -0,0 +1,1257 @@
+[
+    {
+        "type": "text",
+        "text": "SegFormer: Simple and Efficient Design for Semantic Segmentation with Transformers ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            122,
+            823,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "nze Xie1 Wenhai Wang2 Zhiding $\\mathbf { Y } \\mathbf { u } ^ { 3 * }$ Anima Anandkumar3,4 Jose M. Alvarez3 Ping Luo1 1The University of Hong Kong 2Nanjing University 3NVIDIA 4Caltech ",
+        "bbox": [
+            191,
+            223,
+            826,
+            256
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "xieenze@hku.hk, wangwenhai362@163.com, {zhidingy,josea,aanandkumar}@nvidia.com, pluo@cs.hku.hk ",
+        "bbox": [
+            259,
+            261,
+            738,
+            287
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            324,
+            535,
+            340
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present SegFormer, a simple, efficient yet powerful semantic segmentation framework which unifies Transformers with lightweight multilayer perceptron (MLP) decoders. SegFormer has two appealing features: 1) SegFormer comprises a novel hierarchically structured Transformer encoder which outputs multiscale features. It does not need positional encoding, thereby avoiding the interpolation of positional codes which leads to decreased performance when the testing resolution differs from training. 2) SegFormer avoids complex decoders. The proposed MLP decoder aggregates information from different layers, and thus combining both local attention and global attention to render powerful representations. We show that this simple and lightweight design is the key to efficient segmentation on Transformers. We scale our approach up to obtain a series of models from SegFormer-B0 to SegFormer-B5, reaching significantly better performance and efficiency than previous counterparts. For example, SegFormer-B4 achieves $5 0 . 3 \\%$ mIoU on ADE20K with 64M parameters, being $5 \\times$ smaller and $2 . 2 \\%$ better than the previous best method. Our best model, SegFormer-B5, achieves $8 4 . 0 \\%$ mIoU on Cityscapes validation set and shows excellent zero-shot robustness on Cityscapes-C. Code is available at: github.com/NVlabs/SegFormer. ",
+        "bbox": [
+            233,
+            354,
+            766,
+            588
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            611,
+            310,
+            628
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Semantic segmentation is a fundamental task in computer vision and enables many downstream applications. It is related to image classification since it produces per-pixel category prediction instead of image-level prediction. This relationship is pointed out and systematically studied in a seminal work [1], where the authors used fully convolutional networks (FCNs) for semantic segmentation tasks. Since then, FCN has inspired many follow-up works and has become a predominant design choice for dense prediction. ",
+        "bbox": [
+            174,
+            642,
+            490,
+            794
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Since there is a strong relation between classification and semantic segmentation, many stateof-the-art semantic segmentation frameworks are variants of popular architectures for image classification on ImageNet. Therefore, designing backbone architectures has remained an active area ",
+        "bbox": [
+            176,
+            801,
+            491,
+            883
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/5007e085fb335dab4808d5eafa6f0f84083b9738fa10bc625833f861e039486b.jpg",
+        "image_caption": [
+            "Figure 1: Performance vs. model efficiency on ADE20K. SegFormer achieves a new state-of-the-art $5 1 . 0 \\%$ mIoU while being significantly more efficient than previous methods. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            511,
+            642,
+            816,
+            856
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "in semantic segmentation. Indeed, starting from early methods using VGGs [1, 2], to the latest methods with significantly deeper and more powerful backbones [3], the evolution of backbones has dramatically pushed the performance boundary of semantic segmentation. Besides backbone architectures, another line of work formulates semantic segmentation as a structured prediction problem, and focuses on designing modules and operators, which can effectively capture contextual information. A representative example in this area is dilated convolution [4, 5], which increases the receptive field by “inflating” the kernel with holes. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Witnessing the great success in natural language processing (NLP), there has been a recent surge of interest to introduce Transformers to vision tasks. Dosovitskiy et al. [6] proposed vision Transformer (ViT) for image classification. Following the Transformer design in NLP, the authors split an image into multiple linearly embedded patches and feed them into a standard Transformer with positional embeddings (PE), leading to an impressive performance on ImageNet. In semantic segmentation, Zheng et al. [7] proposed SETR to demonstrate the feasibility of using Transformers in this task. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            279
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "SETR adopts ViT as a backbone and incorporates several CNN decoders to enlarge feature resolution. Despite the good performance, ViT has two important limitations: 1) ViT outputs single-scale lowresolution features instead of multi-scale ones, and 2) it has very high computational cost on large images. To address these limitations, Wang et al. [8] proposed a pyramid vision Transformer (PVT), a natural extension of ViT with pyramid structures for dense prediction. PVT shows considerable improvements over the ResNet counterpart on object detection and semantic segmentation. However, together with other emerging methods such as Swin Transformer [9] and Twins [10], these methods mainly consider the design of the Transformer encoder, neglecting the contribution of the decoder for further improvements. ",
+        "bbox": [
+            174,
+            284,
+            825,
+            409
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces SegFormer, a cutting-edge Transformer framework for semantic segmentation that jointly considers efficiency, accuracy, and robustness. In contrast to previous methods, our framework redesigns both the encoder and the decoder. The key novelties of our approach are: ",
+        "bbox": [
+            176,
+            415,
+            823,
+            457
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• A novel positional-encoding-free and hierarchical Transformer encoder.   \n• A lightweight All-MLP decoder design that yields a powerful representation without complex and computationally demanding modules.   \n• As shown in Figure 1, SegFormer sets new a state-of-the-art in terms of efficiency, accuracy and robustness in three publicly available semantic segmentation datasets. ",
+        "bbox": [
+            173,
+            469,
+            825,
+            553
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "First, the proposed encoder avoids interpolating positional codes when performing inference on images with resolutions different from the training one. As a result, our encoder can easily adapt to arbitrary test resolutions without impacting the performance. In addition, the hierarchical part enables the encoder to generate both high-resolution fine features and low-resolution coarse features, this is in contrast to ViT that can only produce single low-resolution feature maps with fixed resolutions. Second, we propose a lightweight MLP decoder where the key idea is to take advantage of the Transformer-induced features where the attentions of lower layers tend to stay local, whereas the ones of the highest layers are highly non-local. By aggregating the information from different layers, the MLP decoder combines both local and global attention. As a result, we obtain a simple and straightforward decoder that renders powerful representations. ",
+        "bbox": [
+            173,
+            565,
+            825,
+            704
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate the advantages of SegFormer in terms of model size, run-time, and accuracy on three publicly available datasets: ADE20K, Cityscapes, and COCO-Stuff. On Citysapces, our lightweight model, SegFormer-B0, without accelerated implementations such as TensorRT, yields $7 1 . 9 \\%$ mIoU at 48 FPS, which, compared to ICNet [11], represents a relative improvement of $60 \\%$ and $4 . 2 \\%$ i n latency and performance, respectively. Our largest model, SegFormer-B5, yields $8 4 . 0 \\%$ mIoU, which represents a relative $1 . 8 \\%$ mIoU improvement while being $5 \\times$ faster than SETR [7]. On ADE20K, this model sets a new state-of-the-art of $5 1 . 8 \\%$ mIoU while being $4 \\times$ smaller than SETR. Moreover, our approach is significantly more robust to common corruptions and perturbations than existing methods, therefore being suitable for safety-critical applications. Code will be publicly available. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            835
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/4ff2abbdc57e6a2df1d3d69c5bae5df978345483cbe78a959ab4764aa8704413.jpg",
+        "image_caption": [
+            "Figure 2: The proposed SegFormer framework consists of two main modules: A hierarchical Transformer encoder to extract coarse and fine features; and a lightweight All-MLP decoder to directly fuse these multi-level features and predict the semantic segmentation mask. “FFN” indicates feed-forward network. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            92,
+            756,
+            296
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            353,
+            321,
+            371
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Semantic Segmentation. Semantic segmentation can be seen as an extension of image classification from image level to pixel level. In the deep learning era [12–14], FCN [1] is the fundamental work of semantic segmentation, which is a fully convolution network that performs pixel-to-pixel classification in an end-to-end manner. After that, researchers focused on improving FCN from different aspects such as: enlarging the receptive field [15–17, 5, 2, 4, 18]; refining the contextual information [19– 27]; introducing boundary information [28–35]; designing various attention modules [36–44]; or using AutoML technologies [45–49]. These methods significantly improve semantic segmentation performance at the expense of introducing many empirical modules, making the resulting framework computationally demanding and complicated. More recent methods have proved the effectiveness of Transformer-based architectures for semantic segmentation [7, 44]. However, these methods are still computationally demanding. ",
+        "bbox": [
+            174,
+            385,
+            826,
+            537
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Transformer backbones. ViT [6] is the first work to prove that a pure Transformer can achieve state-of-the-art performance in image classification. ViT treats each image as a sequence of tokens and then feeds them to multiple Transformer layers to make the classification. Subsequently, DeiT [50] further explores a data-efficient training strategy and a distillation approach for ViT. More recent methods such as T2T ViT [51], CPVT [52], TNT [53], CrossViT [54] and LocalViT [55] introduce tailored changes to ViT to further improve image classification performance. ",
+        "bbox": [
+            174,
+            542,
+            825,
+            627
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Beyond classification, PVT [8] is the first work to introduce a pyramid structure in Transformer, demonstrating the potential of a pure Transformer backbone compared to CNN counterparts in dense prediction tasks. After that, methods such as Swin [9], CvT [56], CoaT [57], LeViT [58] and Twins [10] enhance the local continuity of features and remove fixed size position embedding to improve the performance of Transformers in dense prediction tasks. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            702
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Transformers for specific tasks. DETR [50] is the first to use Transformers for end-to-end object detection framework without non-maximum suppression (NMS). Other works have also used Transformers in tasks such as tracking [59, 60], super-resolution [61], re-id [62], colorization [63], retrieval [64] and multi-modal learning [65, 66]. For semantic segmentation, SETR [7] adopts ViT [6] as a backbone to extract features, achieving impressive performance. However, these Transformer-based methods have very low efficiency and, thus, difficult to deploy in real-time applications. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            791
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            810,
+            269,
+            827
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As depicted in Figure 2, SegFormer consists of two main modules: (1) a hierarchical Transformer encoder; and (2) a lightweight All-MLP decoder to predict the final mask. Given an image with size $H \\times W \\times 3$ , we first divide it into patches of size $4 \\times 4$ . Unlike ViT which uses $1 6 \\times 1 6$ , using fine-grained patches favors semantic segmentation. Second, we use these patches as input to the hierarchical Transformer encoder to get multi-level features with resolution {1/4, 1/8, 1/16, 1/32} of the original image. We then pass these multi-level features to the All-MLP decoder to predict the segmentation mask with a $\\begin{array} { r } { \\frac { H } { 4 } \\times \\frac { W } { 4 } \\times N _ { c l s } } \\end{array}$ resolution, where $N _ { c l s }$ is the number of categories. In the remainder of this section, we first detail the proposed encoder and decoder designs and then summarize the main differences of our approach compared to SETR. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            826,
+            147
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Hierarchical Transformer Encoder ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            162,
+            455,
+            178
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We design a series of Mix Transformer encoders (MiT), MiT-B0 to MiT-B5, with the same architecture but different sizes. On top of the hierarchical architecture and efficient self-attention module in PVT [8], we further propose several novel features including overlapped patch merging and positional-encoding-free design which will be shown to greatly benefit the segmentation tasks. ",
+        "bbox": [
+            174,
+            188,
+            826,
+            244
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Hierarchical Feature Representation. Unlike ViT [6], our encoder generates multi-level multi-scale features given an input image. These features provide both high-resolution coarse features and lowresolution fine-grained features that boost the performance of semantic segmentation. Specifically, givemap n input image with siwith a resolution of $H \\times W \\times 3$ perform, where to o, and a hierarchical fis larger than ure  . $F _ { i }$ $\\begin{array} { r } { \\frac { H } { 2 ^ { i + 1 } } \\times \\frac { W } { 2 ^ { i + 1 } } \\times C _ { i } } \\end{array}$ $i \\in \\{ 1 , 2 , 3 , 4 \\}$ $C _ { i + 1 }$ $C _ { i }$ ",
+        "bbox": [
+            174,
+            250,
+            825,
+            321
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Efficient Self-Attention. A major bottleneck of the above hierarchical feature representation is the quadratic self-attention complexity with long sequence inputs from higher resolution features. Recall that in the original multi-head self-attention, each of the heads $Q , K , V$ have the same dimensions $N \\times C$ , where $N = H \\times W$ is the length of the sequence, the self-attention is estimated as: ",
+        "bbox": [
+            173,
+            325,
+            825,
+            382
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/22c6f17300488186748ee8ab1a6594a67b8a5ec60b568bfdc56df4a256d97e9e.jpg",
+        "text": "$$\n\\mathrm { A t t e n t i o n } ( Q , K , V ) = \\mathrm { S o f t m a x } ( \\frac { Q K ^ { \\mathsf { T } } } { \\sqrt { d _ { h e a d } } } ) V .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            386,
+            650,
+            422
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We instead adopt the sequence reduction process introduced in [8]. This process uses a reduction ratio $R$ to reduce the length of the sequence of as follows: ",
+        "bbox": [
+            173,
+            426,
+            823,
+            454
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e04dbc7a636c8d1fd1d6b1ec640989dc2e383a255a4004c5ab75c616592bf783.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle \\hat { K } = \\mathrm { R e s h a p e } ( \\frac { N } { R } , C \\cdot R ) ( K ) } } \\\\ { { \\displaystyle K = \\mathrm { L i n e a r } ( C \\cdot R , C ) ( \\hat { K } ) , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            458,
+            599,
+            511
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $K$ is the sequence to be reduced, Reshape $\\begin{array} { r } { \\big ( \\frac { N } { R } , C \\cdot R ) ( K ) } \\end{array}$ refers to reshape $K$ to the one with shape of NR $\\begin{array} { r } { \\frac { N } { R } \\times ( C \\cdot R ) } \\end{array}$ , and Linear $( C _ { i n } , C _ { o u t } ) ( \\cdot )$ refers to a linear layer taking a $C _ { i n }$ -dimensional tensor as input and generating a $C _ { o u t }$ -dimensional tensor as output. Therefore, the new $K$ has dimensions $\\begin{array} { r } { \\frac { N } { R } \\times C } \\end{array}$ . As a result, the complexity of the self-attention mechanism is reduced from $O ( N ^ { 2 } )$ to $O ( \\textstyle { \\frac { N ^ { 2 } } { R } } )$ . In our experiments, we set $R$ to [64, 16, 4, 1] from stage-1 to stage-4. ",
+        "bbox": [
+            173,
+            515,
+            825,
+            594
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Overlapped Patch Merging. Given an image patch, the patch merging process used in ViT, unifies a $N \\times N \\times 3$ patch into a $1 \\times 1 \\times C$ vector. This can easily be extended to unify a $2 \\times 2 \\times C _ { i }$ feature path into a $1 \\times 1 \\times C _ { i + 1 }$ vector to obtain hierarchical feature maps. Using this, we can shrink our hierarchical features from other feature map in the hierar $F _ { 1 }$ . $\\begin{array} { r } { \\frac { H } { 4 } \\times \\frac { W } { 4 } \\times C _ { 1 } ) } \\end{array}$ to s i $F _ { 2 }$ a $\\begin{array} { r } { ( \\frac { H } { 8 } \\times \\frac { W } { 8 } \\times C _ { 2 } ) } \\end{array}$ , and then iterate for anycombine non-overlapping image or feature patches. Therefore, it fails to preserve the local continuity around those patches. Instead, we use an overlapping patch merging process. To this end, we define $K , S ,$ , and $P$ , where $K$ is the patch size, $S$ is the stride between two adjacent patches, and $P$ is the padding size. In our experiments, we set $K = 7$ , $S = 4$ , $P = 3$ ,and $K = 3$ , $S = 2$ , $P = 1$ to perform overlapping patch merging to produces features with the same size as the non-overlapping process. Similar to the original patch embedding in ViT [6], this operation can be implemented by “nn.Conv2D” in PyTorch. ",
+        "bbox": [
+            173,
+            598,
+            826,
+            753
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Positional-Encoding-Free Design. The resolution of the PE in ViT is fixed. One thus needs to interpolate the PE when the test resolution differs from training. This leads to the drop of accuracy, which is undesirable since the resolution mismatch is common in semantic segmentation. We instead introduce Mix-FFN where we consider the effect of zero padding to the leak location information [67] by directly using a $3 \\times 3$ Conv in the feed-forward network (FFN). Mix-FFN is formulated as: ",
+        "bbox": [
+            173,
+            758,
+            825,
+            829
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/99e237820ef79bb4a1b52c6008cc27941a63b32ff037fd093457bcae30b296f4.jpg",
+        "text": "$$\n\\begin{array} { r } { { \\bf x } _ { o u t } = \\bf M L P ( \\mathrm { G E L U } ( \\mathrm { C o n v } _ { 3 \\times 3 } ( \\mathbf { M L P } ( \\mathbf { x } _ { i n } ) ) ) ) + x _ { i n } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            833,
+            669,
+            851
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\bf x } _ { i n }$ is the feature from the self-attention module. Mix-FFN mixes a $3 \\times 3$ convolution and an MLP into each FFN. In our experiments, we will show that a $3 \\times 3$ convolution is sufficient to provide positional information for Transformers. In particular, we use depth-wise convolutions for reducing the number of parameters and improving efficiency. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It should be mentioned that CPVT [52] also alleviates this issue by using a $3 \\times 3$ Conv to generate conditional PE at different resolutions and then add it to the feature map. Our work conceptually goes one step further as we argue that adding PE to feature map is not necessary in semantic segmentation. Another recent work CvT [56] introduced $3 \\times 3$ Convs to model the spatial relationship among tokens. Despite the converging design, our work differs in both motivation and application as we aim to totally remove PEs to handle the training/testing resolution mismatch issue in semantic segmentation. Our intuition started from [67] whereas the same intuition was not discussed in CvT. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            189
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Lightweight All-MLP Decoder ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            204,
+            424,
+            219
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "SegFormer incorporates a lightweight decoder consisting only of MLP layers and this avoiding the hand-crafted and computationally demanding components typically used in other methods. The key to enabling such a simple decoder is that our hierarchical Transformer encoder has a larger effective receptive field (ERF) than traditional CNN encoders. ",
+        "bbox": [
+            174,
+            229,
+            825,
+            285
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The proposed All-MLP decoder consists of four main steps. First, multi-level features $F _ { i }$ from the MiT encoder go through an MLP layer to unify the channel dimension. Then, in a second step, features are up-sampled to 1/4th and concatenated together. Third, a MLP layer is adopted to fuse the concatenated features $F$ . Finally, another MLP layer takes the fused feature to predict the segmentation mask $M$ with a $\\begin{array} { r } { \\frac { H } { 4 } \\times \\frac { W } { 4 } \\times N _ { c l s } } \\end{array}$ resolution, where $N _ { c l s }$ is the number of categories. This lets us formulate the decoder as: ",
+        "bbox": [
+            173,
+            291,
+            825,
+            375
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1d0087aea36d1912fc5131423e4a345273f06082ac7fe376065ccbf6a7da633b.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\hat { F } _ { i } = \\mathrm { L i n e a r } ( C _ { i } , C ) ( F _ { i } ) , \\forall i } \\\\ & { \\hat { F } _ { i } = \\mathrm { U p s a m p l e } ( \\cfrac { W } { 4 } \\times \\cfrac { W } { 4 } ) ( \\hat { F } _ { i } ) , \\forall i } \\\\ & { F = \\mathrm { L i n e a r } ( 4 C , C ) ( \\mathrm { C o n c a t } ( \\hat { F } _ { i } ) ) , \\forall i } \\\\ & { M = \\mathrm { L i n e a r } ( C , N _ { c l s } ) ( F ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            377,
+            622,
+            468
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where M refers to the predicted mask, and Linear $( C _ { i n } , C _ { o u t } ) ( \\cdot )$ refers to a linear layer with $C _ { i n }$ and $C _ { o u t }$ as input and output vector dimensions respectively. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Effective Receptive Field Analysis. For semantic segmentation, maintaining large receptive field to include context information has been a central issue [5, 17, 18]. Here, we use effective receptive field (ERF) [68] as a toolkit to visualize and interpret why our MLP decoder design is so effective on Transformers. In Figure 3, we visualize ERFs of the four encoder stages and the decoder heads for both DeepLabv $^ { 3 + }$ and SegFormer. We can make the following observations: ",
+        "bbox": [
+            174,
+            510,
+            421,
+            689
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/da07201f1be04852378cd87d5b5e091969253bcbfea5e17953f5e74b2a931d7b.jpg",
+        "image_caption": [
+            "Figure 3: Effective Receptive Field (ERF) on Cityscapes (average over 100 images). Top row: Deeplabv $^ { 3 + }$ . Bottom row: SegFormer. ERFs of the four stages and the decoder heads of both architectures are visualized. Best viewed with zoom in. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            437,
+            512,
+            821,
+            621
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• The ERF of DeepLabv $^ { 3 + }$ is relatively small even at Stage-4, the deepest stage. • SegFormer’s encoder naturally produces local attentions which resemble convolutions at lower stages, while able to output highly non-local attentions that effectively capture contexts at Stage-4. • As shown with the zoom-in patches in Figure 3, the ERF of the MLP head (blue box) differs from Stage-4 (red box) with a significant stronger local attention besides the non-local attention. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            781
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The limited receptive field in CNN requires one to resort to context modules such as ASPP [16] that enlarge the receptive field but inevitably become heavy. Our decoder design benefits from the non-local attention in Transformers and leads to a larger receptive field without being complex. The same decoder design, however, does not work well on CNN backbones since the overall receptive field is upper bounded by the limited one at Stage-4, and we will verify this later in Table 1d, ",
+        "bbox": [
+            174,
+            794,
+            825,
+            863
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "More importantly, our decoder design essentially takes advantage of a Transformer induced feature that produces both highly local and non-local attention at the same time. By unifying them, our MLP decoder renders complementary and powerful representations by adding few parameters. This is another key reason that motivated our design. Taking the non-local attention from Stage-4 alone is not enough to produce good results, as will be verified in Table 1d. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 Relationship to SETR. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            138,
+            367,
+            154
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "SegFormer contains multiple more efficient and powerful designs compared with SETR [7]: ",
+        "bbox": [
+            171,
+            165,
+            776,
+            180
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• We only use ImageNet-1K for pre-training. ViT in SETR is pre-trained on larger ImageNet-22K.   \n• SegFormer’s encoder has a hierarchical architecture, which is smaller than ViT and can capture both high-resolution coarse and low-resolution fine features. In contrast, SETR’s ViT encoder can only generate single low-resolution feature map.   \n• We remove Positional Embedding in encoder, while SETR uses fixed shape Positional Embedding which decreases the accuracy when the resolution at inference differs from the training ones.   \n• Our MLP decoder is more compact and less computationally demanding than the one in SETR. This leads to a negligible computational overhead. In contrast, SETR requires heavy decoders with multiple $3 \\times 3$ convolutions. ",
+        "bbox": [
+            173,
+            188,
+            826,
+            333
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            356,
+            312,
+            373
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experimental Settings ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            388,
+            367,
+            404
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets: We used four public datasets: Cityscapes [69], ADE20K [70], and COCO-Stuff [71]. ADE20K is a dataset covering 150 fine-grained semantic concepts consisting of 20210 images. Cityscapes is a driving dataset for semantic segmentation consisting of 5000 fine-annotated high resolution images with 19 categories. COCO-Stuff covers 172 labels and consists of 164k images: 118k for training, $5 \\mathrm { k }$ for validation, $2 0 \\mathrm { k }$ for test-dev and $2 0 \\mathrm { k }$ for the test-challenge. ",
+        "bbox": [
+            174,
+            415,
+            826,
+            484
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation details: We used the mmsegmentation2 codebase and train on a server with 8 Tesla V100. We pre-train the encoder on the Imagenet-1K dataset and randomly initialize the decoder. During training, we applied data augmentation through random resize with ratio 0.5-2.0, random horizontal flipping, and random cropping to $5 1 2 \\times 5 1 2$ , $1 0 2 4 \\times 1 0 2 4$ , $5 1 2 \\times 5 1 2$ for ADE20K, Cityscapes and COCO-Stuff. Following [9] we set crop size to $6 4 0 \\times 6 4 0$ on ADE20K for our largest model B5. We trained the models using AdamW optimizer for 160K iterations on ADE20K, Cityscapes, and 80K iterations on COCO-Stuff. Exceptionally, for the ablation studies, we trained the models for 40K iterations. We used a batch size of 16 for ADE20K, COCO-Stuff and a batch size of 8 for Cityscapes. The learning rate was set to an initial value of 0.00006 and then used a “poly” LR schedule with factor 1.0 by default. For simplicity, we did not adopt widely-used tricks such as OHEM, auxiliary losses or class balance loss. During evaluation, we rescale the short side of the image to training cropping size and keep the aspect ratio for ADE20K and COCO-Stuff. For Cityscapes, we do inference using sliding window test by cropping $1 0 2 4 \\times 1 0 2 4$ windows. We report semantic segmentation performance using mean Intersection over Union (mIoU). ",
+        "bbox": [
+            173,
+            491,
+            826,
+            684
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Ablation Studies ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            703,
+            328,
+            718
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Influence of the size of model. We first analyze the effect of increasing the size of the encoder on the performance and model efficiency. Figure 1 shows the performance vs. model efficiency for ADE20K as a function of the encoder size and, Table 1a summarizes the results for the three datasets. The first thing to observe here is the size of the decoder compared to the encoder. As shown, for the lightweight model, the decoder has only 0.4M parameters. For MiT-B5 encoder, the decoder only takes up to $4 \\%$ of the total number of parameters in the model. In terms of performance, we can observe that, overall, increasing the size of the encoder yields consistent improvements on all the datasets. Our lightweight model, SegFormer-B0, is compact and efficient while maintaining a competitive performance, showing that our method is very convenient for real-time applications. On the other hand, our SegFormer-B5, the largest model, achieves state-of-the-art results on all three datasets, showing the potential of our Transformer encoder. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            882
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/e1f1e7f892767e2d49355a8ce3722a614d79b78b0b876f6e64d0a778743f8021.jpg",
+        "table_caption": [
+            "Table 1: Ablation studies related to model size, encoder and decoder design. (a) Accuracy, parameters and flops as a function of the model size on the three datasets. “SS” and “MS” means single/multi-scal "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Encoder Model Size</td><td colspan=\"2\">Params</td><td colspan=\"2\">ADE20K</td><td colspan=\"2\">Cityscapes</td><td colspan=\"2\">COCO-Stuff</td></tr><tr><td>Encoder</td><td>Decoder</td><td>Flops</td><td>mIoU(SS/MS) ↑</td><td>Flops↓</td><td>mIoU(SS/MS) ↑</td><td>Flops↓</td><td>mIoU(SS) ↑</td></tr><tr><td>MiT-B0</td><td>3.4</td><td>0.4</td><td>8.4</td><td>37.4 /38.0</td><td>125.5</td><td>76.2 /78.1</td><td>8.4</td><td>35.6</td></tr><tr><td>MiT-B1</td><td>13.1</td><td>0.6</td><td>15.9</td><td>42.2/43.1</td><td>243.7</td><td>78.5 /80.0</td><td>15.9</td><td>40.2</td></tr><tr><td>MiT-B2</td><td>24.2</td><td>3.3</td><td>62.4</td><td>46.5 /47.5</td><td>717.1</td><td>81.0 /82.2</td><td>62.4</td><td>44.6</td></tr><tr><td>MiT-B3</td><td>44.0</td><td>3.3</td><td>79.0</td><td>49.4 / 50.0</td><td>962.9</td><td>81.7 /83.3</td><td>79.0</td><td>45.5</td></tr><tr><td>MiT-B4</td><td>60.8</td><td>3.3</td><td>95.7</td><td>50.3 / 51.1</td><td>1240.6</td><td>82.3 /83.9</td><td>95.7</td><td>46.5</td></tr><tr><td>MiT-B5</td><td>81.4</td><td>3.3</td><td>183.3</td><td>51.0 / 51.8</td><td>1460.4</td><td>82.4/84.0</td><td>111.6</td><td>46.7</td></tr></table>",
+        "bbox": [
+            192,
+            137,
+            805,
+            250
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/dbace1d12849c2420393dfd403c86ca4afe8614d705d249ffaac9e4f8b7417cf.jpg",
+        "table_caption": [
+            "(b) Accuracy as a function of the MLP dimension $C$ in the decoder on ADE20K. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>C</td><td>Flops↓</td><td>Params↓</td><td>mIoU个</td></tr><tr><td>256</td><td>25.7</td><td>24.7</td><td>44.9</td></tr><tr><td>512</td><td>39.8</td><td>25.8</td><td>45.0</td></tr><tr><td>768</td><td>62.4</td><td>27.5</td><td>45.4</td></tr><tr><td>1024</td><td>93.6</td><td>29.6</td><td>45.2</td></tr><tr><td>2048</td><td>304.4</td><td>43.4</td><td>45.6</td></tr></table>",
+        "bbox": [
+            191,
+            282,
+            375,
+            361
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/6436a85408f4eed879b99609cca8f867d11c1db32bf278b5eda4665cbc5ba9d1.jpg",
+        "table_caption": [
+            "(c) Mix-FFN vs. positional encoding (PE) for different test resolution on Cityscapes. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Inf Res</td><td>Enc Type</td><td>mIoU↑</td></tr><tr><td>768×768</td><td>PE</td><td>77.3</td></tr><tr><td>1024×2048</td><td>PE</td><td>74.0</td></tr><tr><td>768×768</td><td>Mix-FFN</td><td>80.5</td></tr><tr><td>1024×2048</td><td>Mix-FFN</td><td>79.8</td></tr></table>",
+        "bbox": [
+            388,
+            281,
+            593,
+            362
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/9b1a9fd26d96ec15838d19a13cfd53c724fb70dcf3c10d5f8871dc85d0407218.jpg",
+        "table_caption": [
+            "(d) Accuracy on ADE20K of CNN and Transformer encoder with MLP decoder. “S4” means stage-4 feature. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Encoder</td><td>Flops ↓</td><td>Params ↓</td><td>mIoU↑</td></tr><tr><td>ResNet50 (S1-4)</td><td>69.2</td><td>29.0</td><td>34.7</td></tr><tr><td>ResNet101 (S1-4)</td><td>88.7</td><td>47.9</td><td>38.7</td></tr><tr><td>ResNeXt101 (S1-4)</td><td>127.5</td><td>86.8</td><td>39.8</td></tr><tr><td>MiT-B2 (S4)</td><td>22.3</td><td>24.7</td><td>43.1</td></tr><tr><td>MiT-B2 (S1-4)</td><td>62.4</td><td>27.7</td><td>45.4</td></tr><tr><td>MiT-B3 (S1-4)</td><td>79.0</td><td>47.3</td><td>48.6</td></tr></table>",
+        "bbox": [
+            607,
+            289,
+            795,
+            363
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/45b2d2a66479ed01510cde0acef387c46d577c50b671e8f3c66f19613b7013b9.jpg",
+        "table_caption": [
+            "Table 2: Comparison to state of the art methods on ADE20K and Cityscapes. SegFormer has significant advantages on #Params (M), #Flops, #Speed and #Accuracy. Note that for SegFormer-B0 we scale the short side of image to {1024, 768, 640, 512} to get speed-accuracy tradeoffs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td rowspan=\"2\">Method</td><td rowspan=\"2\">Encoder</td><td rowspan=\"2\">Params↓</td><td colspan=\"3\">ADE20K</td><td colspan=\"3\">Cityscapes</td></tr><tr><td>Flops↓</td><td>FPS↑</td><td>mIoU↑</td><td>Flops↓</td><td>FPS↑</td><td>mIoU↑</td></tr><tr><td rowspan=\"9\">Pigalr</td><td rowspan=\"2\">FCN[1] ICNet [11]</td><td>MobileNetV2</td><td>9.8</td><td>39.6</td><td>64.4</td><td>19.7</td><td>317.1</td><td>14.2</td><td>61.5</td></tr><tr><td></td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>30.3</td><td>67.7</td></tr><tr><td>PSPNet [15]</td><td>MobileNetV2</td><td>13.7</td><td>52.9</td><td>57.7</td><td>29.6</td><td>423.4</td><td>11.2</td><td>70.2</td></tr><tr><td>DeepLabV3+[18]</td><td>MobileNetV2</td><td>15.4</td><td>69.4</td><td>43.1</td><td>34.0</td><td>555.4</td><td>8.4</td><td>75.2</td></tr><tr><td rowspan=\"5\">SegFormer (Ours)</td><td rowspan=\"5\">MiT-BO</td><td rowspan=\"5\"></td><td>8.4 -</td><td>50.5</td><td>37.4</td><td>125.5</td><td>15.2</td><td>76.2</td></tr><tr><td>3.8</td><td>-</td><td>-</td><td>51.7</td><td>26.3</td><td>75.3</td></tr><tr><td></td><td>-</td><td>-</td><td>31.5</td><td>37.1</td><td>73.7</td></tr><tr><td>-</td><td>-</td><td>1</td><td>17.7</td><td>47.6</td><td>71.9</td></tr><tr><td>68.6</td><td>14.8</td><td>41.4</td><td>2203.3</td><td>1.2</td><td>76.6</td></tr><tr><td rowspan=\"9\">Nnr arrirr</td><td>EncNet [22]</td><td>ResNet-101 ResNet-101</td><td>55.1</td><td>275.7 218.8</td><td>14.9</td><td>44.7</td><td>1748.0</td><td>1.3</td><td>76.9</td></tr><tr><td>PSPNet [15]</td><td>ResNet-101</td><td>68.1</td><td>256.4</td><td>15.3</td><td>44.4</td><td>2048.9</td><td>1.2</td><td>78.5</td></tr><tr><td>CCNet [39]</td><td>ResNet-101</td><td>68.9</td><td>278.4</td><td>14.1</td><td>45.2</td><td>2224.8</td><td>1.0</td><td>80.2</td></tr><tr><td>DeeplabV3+ [18]</td><td>ResNet-101</td><td>62.7</td><td>255.1</td><td>14.1</td><td>44.1</td><td>2032.3</td><td>1.2</td><td>80.9</td></tr><tr><td>OCRNet [21]</td><td>HRNet-W48</td><td>70.5</td><td>164.8</td><td>17.0</td><td>45.6</td><td>1296.8</td><td>4.2</td><td>81.1</td></tr><tr><td>GSCNN [33]</td><td>WideResNet38</td><td>-</td><td>1</td><td>-</td><td>-</td><td>-</td><td>1</td><td>80.8</td></tr><tr><td>Axial-DeepLab [72]</td><td>AxialResNet-XL</td><td></td><td>-</td><td>-</td><td>1</td><td>2446.8</td><td>-</td><td>81.1</td></tr><tr><td>Dynamic Routing [73] Auto-Deeplab [48]</td><td>Dynamic-L33-PSP</td><td></td><td>=</td><td>=</td><td>- 44.0</td><td>270.0</td><td>-</td><td>80.7 80.3</td></tr><tr><td>SETR[7]</td><td>NAS-F48-ASPP</td><td>-</td><td>-</td><td>- 5.4</td><td>50.2</td><td>695.0</td><td>1 0.5</td><td></td></tr><tr><td></td><td>ViT-Large</td><td>318.3</td><td>-</td><td></td><td></td><td></td><td>-</td><td></td><td>82.2</td></tr><tr><td>SegFormer(Ours)</td><td></td><td>MiT-B4</td><td>64.1</td><td>95.7</td><td>15.4</td><td>51.1</td><td>1240.6</td><td>3.0</td><td>83.8</td></tr><tr><td>SegFormer (Ours)</td><td></td><td>MiT-B5</td><td>84.7</td><td>183.3</td><td>9.8</td><td>51.8</td><td>1447.6</td><td>2.5</td><td>84.0</td></tr></table>",
+        "bbox": [
+            187,
+            410,
+            807,
+            678
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Influence of $C$ , the MLP decoder channel dimension. We now analyze the influence of the channel dimension $C$ in the MLP decoder, see Section 3.2. In Table 1b we show performance, flops, and parameters as a function of this dimension. We can observe that setting $C \\ : = \\ : 2 5 6$ provides a very competitive performance and computational cost. The performance increases as $C$ increases; however, it leads to larger and less efficient models. Interestingly, this performance plateaus for channel dimensions wider than 768. Given these results, we choose $C = 2 5 6$ for our real-time models SegFormer-B0, B1 and $C = 7 6 8$ for the rest. ",
+        "bbox": [
+            173,
+            689,
+            825,
+            787
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Mix-FFN vs. Positional Encoder (PE). In this experiment, we analyze the effect of removing the positional encoding in the Transformer encoder in favor of using the proposed Mix-FFN. To this end, we train Transformer encoders with a positional encoding (PE) and the proposed Mix-FFN and perform inference on Cityscapes with two different image resolutions: $7 6 8 \\times 7 6 8$ using a sliding window, and $1 0 2 4 \\times 2 0 4 8$ using the whole image. ",
+        "bbox": [
+            174,
+            792,
+            825,
+            863
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1c shows the results for this experiment. As shown, for a given resolution, our approach using Mix-FFN clearly outperforms using a positional encoding. Moreover, our approach is less sensitive to differences in the test resolution: the accuracy drops $3 . 3 \\%$ when using a positional encoding with a lower resolution. In contrast, when we use the proposed Mix-FFN the performance drop is reduced to only $0 . 7 \\%$ . From these results, we can conclude using the proposed Mix-FFN produces better and more robust encoders than those using positional encoding. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            133
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Effective receptive field evaluation. In Section 3.2, we argued that our MLP decoder benefits from Transformers having a larger effective receptive field compared to other CNN models. To quantify this effect, in this experiment, we compare the performance of our MLP-decoder when used with CNN-based encoders such as ResNet or ResNeXt. As shown in Table 1d, coupling our MLP-decoder with a CNN-based encoder yields a significantly lower accuracy compared to coupling it with the proposed Transformer encoder. Intuitively, as a CNN has a smaller receptive field than the Transformer (see the analysis in Section 3.2), the MLP-decoder is not enough for global reasoning. In contrast, coupling our Transformer encoder with the MLP decoder leads to the best performance. Moreover, for Transformer encoder, it is necessary to combine low-level local features and high-level non-local features instead of only high-level feature. ",
+        "bbox": [
+            173,
+            140,
+            825,
+            277
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Influence of difference encoders. We select 2 representative Transformer encoders, ViT [6] and Swin [9] and compare with our MiT encoder. As shown in Table 3, with same decoder, e.g.MLP decoder, MiT-B2 is $3 . 1 \\%$ higher than Swin-T with similar encoder parameters. Moreover, MiT-B5 has much fewer encoder parameters than ViT-large, but is $3+ \\%$ mIoU higher than ViT-large. These experiments shows our MiT encoder is better than Swin and ViT for semantic segmentataion. ",
+        "bbox": [
+            174,
+            285,
+            485,
+            435
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Influence of difference decoders. We also test MiT encoder with different decoders. As shown ",
+        "bbox": [
+            173,
+            443,
+            485,
+            470
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/9aba1e1ecb97f4f074577984ee6b7af1587374fcbf0b102153d53fb8f7e61130.jpg",
+        "table_caption": [
+            "Table 3: Ablation study of different Transformer encoders and different decoders. All the model are trained on ADE20K with 160K iterations. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Encoder</td><td>Decoder</td><td>mIoU</td><td>FPS</td><td>Decoder GFlops</td><td>Decoder Params (M)</td></tr><tr><td>MiT-B2</td><td>UperNet (Swin)</td><td>46.5</td><td>14.2</td><td>210.7</td><td>29.7</td></tr><tr><td>MiT-B2</td><td>MLA (SETR)</td><td>46.2</td><td>9.5</td><td>87.7</td><td>4.2</td></tr><tr><td>MiT-B2</td><td>MLP(Ours)</td><td>46.5</td><td>21.4</td><td>42.1</td><td>3.3</td></tr><tr><td>MiT-B5</td><td>UperNet (Swin)</td><td>50.7</td><td>5.3</td><td>210.7</td><td>29.7</td></tr><tr><td>MiT-B5</td><td>MLA (SETR)</td><td>50.9</td><td>3.8</td><td>87.7</td><td>4.2</td></tr><tr><td>MiT-B5</td><td>MLP(Ours)</td><td>51.0</td><td>9.8</td><td>42.1</td><td>3.3</td></tr><tr><td>Swin-T</td><td>MLP(Ours)</td><td>43.4</td><td>20.6</td><td>42.8</td><td>3.6</td></tr><tr><td>Swin-T</td><td>UperNet (Swin)</td><td>44.5</td><td>15.4</td><td>211.3</td><td>31.4</td></tr><tr><td>ViT-L</td><td>MLP(Ours)</td><td>47.7</td><td>4.7</td><td>0.6</td><td>0.6</td></tr><tr><td>ViT-L</td><td>MLA (SETR)</td><td>47.7</td><td>4.6</td><td>1.8</td><td>3.7</td></tr></table>",
+        "bbox": [
+            500,
+            315,
+            820,
+            449
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "in Table 3, the mIoUs are similar with different decoders while the proposed MLP decoder has the least parameters and is only $1 / 8$ of the UperNet decoder in Swin. The MLP decoder is thus an important design towards efficient segmentation. ",
+        "bbox": [
+            174,
+            470,
+            826,
+            512
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Comparison to state of the art methods ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            532,
+            483,
+            546
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We now compare our results with existing approaches on the ADE20K [70] and Cityscapes [69].   \nMore experiments about COCO-Stuff [71] are in appendix. ",
+        "bbox": [
+            176,
+            559,
+            823,
+            588
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ADE20K and Cityscapes: Table 2 summarizes our results including parameters, FLOPS, latency, and accuracy for ADE20K and Cityscapes. In the top part of the table, we report real-time approaches where we include state-of-the-art methods and our results using the MiT-B0 lightweight encoder. In the bottom part, we focus on performance and report the results of our approach and related works using stronger encoders. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            655
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On ADE20K, SegFormer-B0 yields $3 7 . 4 \\%$ mIoU using only $3 . 8 \\mathbf { M }$ parameters and 8.4G FLOPs, outperforming all other real-time counterparts in terms of parameters, flops, and latency. For instance, compared to Deeplab ${ \\mathrm { V } } 3 +$ (MobileNetV2), SegFormer-B0 is 7.4 FPS, which is faster and keeps $3 . 4 \\%$ better mIoU. ",
+        "bbox": [
+            174,
+            662,
+            485,
+            760
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Moreover, SegFormer-B5 outperforms all other approaches, including the previous best SETR, and establishes a new state-of-the-art of $5 1 . 8 \\%$ , which is $1 . 6 \\%$ mIoU better than SETR while being significantly more efficient. ",
+        "bbox": [
+            174,
+            766,
+            486,
+            835
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/0751370674107ea7684553c8f60526927dafabbe144e251fd18f7cb41ca099e2.jpg",
+        "table_caption": [
+            "Table 4: Comparison to state of the art methods on Cityscapes test set. IM-1K, IM-22K, Coarse and MV refer to the ImageNet-1K, ImageNet-22K, Cityscapes coarse set and Mapillary Vistas. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Encoder</td><td>Extra Data</td><td>mIoU</td></tr><tr><td>PSPNet [15]</td><td>ResNet-101</td><td>IM-1K</td><td>78.4</td></tr><tr><td>PSANet [41]</td><td>ResNet-101</td><td>IM-1K</td><td>80.1</td></tr><tr><td>CCNet [39]</td><td>ResNet-101</td><td>IM-1K</td><td>81.9</td></tr><tr><td>OCNet[19]</td><td>ResNet-101</td><td>IM-1K</td><td>80.1</td></tr><tr><td>Axial-DeepLab [72]</td><td>AxiaiResNet-XL</td><td>IM-1K</td><td>79.9</td></tr><tr><td>SETR[7]</td><td>ViT</td><td>IM-22K</td><td>81.0</td></tr><tr><td>SETR [7]</td><td>ViT</td><td>IM-22K,Coarse</td><td>81.6</td></tr><tr><td>SegFormer</td><td>MiT-B5</td><td>IM-1K</td><td>82.2</td></tr><tr><td>SegFormer</td><td>MiT-B5</td><td>IM-1K,MV</td><td>83.1</td></tr></table>",
+        "bbox": [
+            501,
+            703,
+            818,
+            813
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As also shown in Table 2, our results also hold on Cityscapes. SegFormer-B0 yields 15.2 FPS and $7 6 . 2 \\%$ mIoU (the shorter side of input image being 1024), which represents a $1 . 3 \\%$ mIoU improvement and a $2 \\times$ speedup compared to Deeplab ${ \\mathrm { V } } 3 +$ . Moreover, with the shorter side of input image being 512, SegFormer-B0 runs at 47.6 FPS and yields $7 1 . 9 \\%$ mIoU, which is $1 7 . 3 \\mathrm { F P S }$ faster and $4 . 2 \\%$ better than ICNet. SegFormer-B5 archives the best IoU of $8 4 . 0 \\%$ , outperforming all existing methods by at least $1 . 8 \\%$ mIoU, and it runs $5 \\times$ faster and $4 \\times$ smaller than SETR [7]. On Cityscapes test set, we follow the common setting [18] and merge the validation images to the train set and report results using Imagenet-1K pre-training and also using Mapillary Vistas [74]. As reported in Table 4, using only Cityscapes fine data and Imagenet-1K pre-training, our method achieves $8 2 . 2 \\%$ mIoU outperforming all other methods including SETR, which uses ImageNet-22K pre-training and the additional Cityscapes coarse data. Using Mapillary pre-training, our sets a new state-of-the-art result of $8 3 . 1 \\%$ mIoU. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            188
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 Robustness to natural corruptions ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            207,
+            449,
+            222
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Model robustness is important for many safety-critical tasks such as autonomous driving [75]. In this experiment, we evaluate the robustness of SegFormer to common corruptions and perturbations. To this end, we follow [75] and generate Cityscapes-C, which expands the Cityscapes validation set with 16 types of algorithmically generated corruptions from noise, blur, weather and digital categories. We compare our method to Deeplab ${ \\mathrm { V } } 3 +$ and other methods as reported in [75]. We also compare with SETR with DeiT Transformer backbone. The results for this experiment are summarized in Table 5. ",
+        "bbox": [
+            174,
+            233,
+            825,
+            316
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our method significantly outperforms previous CNN-based methods, yielding a relative improvement of up to $58 8 \\%$ on Gaussian Noise and up to $29 5 \\%$ on snow weather. SegFormer also outperforms SETR in general except for one corruption (snow). The results indicate the strong robustness of SegFormer, which we envision to benefit safety-critical applications where robustness is important. ",
+        "bbox": [
+            173,
+            321,
+            825,
+            378
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/2c25e267c49d53936ea05f34a9a721d56736a1f77738a6881c4c3c0b68efd290.jpg",
+        "table_caption": [
+            "Table 5: Main results on Cityscapes-C. $\\mathrm { \\Delta } ^ { \\circ } \\mathrm { D L v } 3 + \\mathrm { \\Delta } ^ { \\circ }$ , “MBv2”, “R” and “X” refer to DeepLabv $^ { 3 + }$ , MobileNetv2, ResNet and Xception. The mIoUs of compared methods are reported from [75]. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td rowspan=\"2\">Clean</td><td colspan=\"4\">Blur</td><td colspan=\"4\">Noise</td><td colspan=\"4\">Digital</td><td colspan=\"4\">Weather</td></tr><tr><td>Motion Defoc Glass Gauss</td><td></td><td></td><td></td><td>Gauss</td><td>Impul Shot Speck Bright Contr Satur JPEG</td><td></td><td></td><td></td><td></td><td></td><td></td><td>Snow</td><td>Spatt Fog</td><td></td><td>Frost</td></tr><tr><td>DLv3+ (MBv2)</td><td>72.0</td><td>53.5</td><td>49.0</td><td>45.3</td><td>49.1</td><td>6.4</td><td>7.0</td><td>6.6</td><td>16.6</td><td>51.7</td><td>46.7</td><td>32.4</td><td>27.2</td><td>13.7</td><td>38.9</td><td>47.4</td><td>17.3</td></tr><tr><td>DLv3+ (R50)</td><td>76.6</td><td>58.5</td><td>56.6</td><td>47.2</td><td>57.7</td><td>6.5</td><td>7.2</td><td>10.0</td><td>31.1</td><td>58.2</td><td>54.7</td><td>41.3</td><td>27.4</td><td>12.0</td><td>42.0</td><td>）55.9</td><td>22.8</td></tr><tr><td>DLv3+ (R101)</td><td>77.1</td><td>59.1</td><td>56.3</td><td>47.7</td><td>57.3</td><td>13.2</td><td>13.9</td><td>16.3</td><td>36.9</td><td>59.2</td><td>54.5</td><td>41.5</td><td>37.4</td><td>11.9</td><td>47.8</td><td>55.1</td><td>22.7</td></tr><tr><td>DLv3+ (X41)</td><td>77.8</td><td>61.6</td><td>54.9</td><td>51.0</td><td>54.7</td><td>17.0</td><td>17.3</td><td>21.6</td><td>43.7</td><td>63.6</td><td>56.9</td><td>51.7</td><td>38.5</td><td>18.2</td><td>46.6</td><td>57.6</td><td>20.6</td></tr><tr><td>DLv3+ (X65)</td><td>78.4</td><td>63.9</td><td>59.1</td><td>52.8</td><td>59.2</td><td>15.0</td><td>10.6</td><td>19.8</td><td>42.4</td><td>65.9</td><td>59.1</td><td>46.1</td><td>31.4</td><td>19.3</td><td>50.7</td><td>63.6</td><td>23.8</td></tr><tr><td>DLv3+ (X71)</td><td>78.6</td><td>64.1</td><td>60.9</td><td>52.0</td><td>60.4</td><td>14.9</td><td>10.8</td><td>19.4</td><td>41.2</td><td>68.0</td><td>58.7</td><td>47.1</td><td>40.2</td><td>18.8</td><td>50.4</td><td>64.1</td><td>20.2</td></tr><tr><td>ICNet</td><td>65.9</td><td>45.8</td><td>44.6</td><td>47.4</td><td>44.7</td><td>8.4</td><td>8.4</td><td>10.6</td><td>27.9</td><td>41.0</td><td>33.1</td><td>27.5</td><td>34.0</td><td>6.3</td><td>30.5</td><td>27.3</td><td>11.0</td></tr><tr><td>FCN8s</td><td>66.7</td><td>42.7</td><td>31.1</td><td>37.0</td><td>34.1</td><td>6.7</td><td>5.7</td><td>7.8</td><td>24.9</td><td>53.3</td><td>39.0</td><td>36.0</td><td>21.2</td><td>11.3</td><td>31.6</td><td>37.6</td><td>19.7</td></tr><tr><td>DilatedNet</td><td>68.6</td><td>44.4</td><td>36.3</td><td>32.5</td><td>38.4</td><td>15.6</td><td>14.0</td><td>18.4</td><td>32.7</td><td>52.7</td><td>32.6</td><td>38.1</td><td>29.1</td><td>12.5</td><td>32.3</td><td>34.7</td><td>19.2</td></tr><tr><td>ResNet-38</td><td>77.5</td><td>54.6</td><td>45.1</td><td>43.3</td><td>47.2</td><td>13.7</td><td>16.0</td><td>18.2</td><td>38.3</td><td>60.0</td><td>50.6</td><td>46.9</td><td>14.7</td><td>13.5</td><td>45.9</td><td>52.9</td><td>22.2</td></tr><tr><td>PSPNet</td><td>78.8</td><td>59.8</td><td>53.2</td><td>44.4</td><td>53.9</td><td>11.0</td><td>15.4</td><td>15.4</td><td>34.2</td><td>60.4</td><td>51.8</td><td>30.6</td><td>21.4</td><td>8.4</td><td>42.7</td><td>34.4</td><td>16.2</td></tr><tr><td>GSCNN</td><td>80.9</td><td>58.9</td><td>58.4</td><td>41.9</td><td>60.1</td><td>5.5</td><td>2.6</td><td>6.8</td><td>24.7</td><td>75.9</td><td>61.9</td><td>70.7</td><td>12.0</td><td>12.4</td><td>47.3</td><td>67.9</td><td>32.6</td></tr><tr><td>SETR-DeiT</td><td>78.9</td><td>64.9</td><td>65.1</td><td>59.1</td><td>65.3</td><td>54.7</td><td>60.5</td><td>51.9</td><td>69.4</td><td>74.9</td><td>69.6</td><td>74.9</td><td>58.5</td><td>44.3</td><td>64.8</td><td>68.2</td><td>39.1</td></tr><tr><td>SegFormer-B5</td><td>82.4</td><td>69.1</td><td>68.6</td><td>64.1</td><td>69.8</td><td>57.8</td><td>63.4</td><td>52.3</td><td>72.8</td><td>81.0</td><td>77.7</td><td>80.1</td><td>58.8</td><td>40.7</td><td>68.4</td><td>78.5</td><td>49.9</td></tr></table>",
+        "bbox": [
+            178,
+            414,
+            823,
+            590
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            616,
+            299,
+            632
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present SegFormer, a simple, clean yet powerful semantic segmentation method which contains a positional-encoding-free, hierarchical Transformer encoder and a lightweight AllMLP decoder. It avoids common complex designs in previous methods, leading to both high efficiency and performance. SegFormer not only achieves new state of the art results on common datasets, but also shows strong zero-shot robustness. We hope our method can serve as a solid baseline for semantic segmentation and motivate further research. One potential limitation is that even our lightest model may still be too heavy for some edge devices. Thus mixed-precision training, pruning, hardware-friendly attention designs and energy consumption are important parts of our future work. ",
+        "bbox": [
+            173,
+            648,
+            826,
+            761
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Broader Impact ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            781,
+            310,
+            799
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Efficiency, accuracy, and robustness are important aspects of AI models. Our work pushes the boundary of semantic segmentation models in these three aspects. We envision that the work will benefit a wide range of safety-critical applications, such as autonomous driving and robot navigation. The proposed method improves the “in-the-wild” robustness of these applications, ultimately leading to better safety. Despite such improvement, we fully understand this work is by no means perfect and there are still many challenges towards reliable real world application. Our models may be subject to biases and other possible undesired mistakes, depending on how they are trained in reality. Our model may also be used for surveillance similar to other AI recognition methods, even though it is not mainly designed for surveillance applications. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            138,
+            553,
+            156
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank Ding Liang, Zhe Chen and Yaojun Liu for insightful discussion without which this paper would not be possible. Ping Luo is supported by the General Research Fund of Hong Kong No.27208720. ",
+        "bbox": [
+            174,
+            170,
+            825,
+            213
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            232,
+            266,
+            247
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In CVPR, 2015. 1, 2, 3, 7 [2] Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L Yuille. Semantic image segmentation with deep convolutional nets and fully connected CRFs. In ICLR, 2015. 2, 3   \n[3] Hang Zhang, Chongruo Wu, Zhongyue Zhang, Yi Zhu, Haibin Lin, Zhi Zhang, Yue Sun, Tong He, Jonas Mueller, R Manmatha, et al. ResNest: Split-attention networks. arXiv, 2020. 2   \n[4] Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected CRFs. TPAMI, 2017. 2, 3   \n[5] Fisher Yu and Vladlen Koltun. Multi-scale context aggregation by dilated convolutions. In ICLR, 2016. 2, 3, 5   \n[6] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv, 2020. 2, 3, 4, 8   \n[7] Sixiao Zheng, Jiachen Lu, Hengshuang Zhao, Xiatian Zhu, Zekun Luo, Yabiao Wang, Yanwei Fu, Jianfeng Feng, Tao Xiang, Philip HS Torr, et al. Rethinking semantic segmentation from a sequence-to-sequence perspective with transformers. CVPR, 2021. 2, 3, 6, 7, 8, 9   \n[8] Wenhai Wang, Enze Xie, Xiang Li, Deng-Ping Fan, Kaitao Song, Ding Liang, Tong Lu, Ping Luo, and Ling Shao. Pyramid vision transformer: A versatile backbone for dense prediction without convolutions. arXiv, 2021. 2, 3, 4   \n[9] Ze Liu, Yutong Lin, Yue Cao, Han Hu, Yixuan Wei, Zheng Zhang, Stephen Lin, and Baining Guo. Swin transformer: Hierarchical vision transformer using shifted windows. arXiv, 2021. 2, 3, 6, 8   \n[10] Xiangxiang Chu, Zhi Tian, Yuqing Wang, Bo Zhang, Haibing Ren, Xiaolin Wei, Huaxia Xia, and Chunhua Shen. Twins: Revisiting spatial attention design in vision transformers. arXiv, 2021. 2, 3   \n[11] Hengshuang Zhao, Xiaojuan Qi, Xiaoyong Shen, Jianping Shi, and Jiaya Jia. Icnet for real-time semantic segmentation on high-resolution images. In ECCV, 2018. 2, 7   \n[12] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. 3   \n[13] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. NeurIPS, 2012.   \n[14] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv, 2014. 3   \n[15] Hengshuang Zhao, Jianping Shi, Xiaojuan Qi, Xiaogang Wang, and Jiaya Jia. Pyramid scene parsing network. In CVPR, 2017. 3, 7, 8   \n[16] Maoke Yang, Kun Yu, Chi Zhang, Zhiwei Li, and Kuiyuan Yang. Denseaspp for semantic segmentation in street scenes. In CVPR, 2018. 5   \n[17] Chao Peng, Xiangyu Zhang, Gang Yu, Guiming Luo, and Jian Sun. Large kernel matters–improve semantic segmentation by global convolutional network. In CVPR, 2017. 3, 5   \n[18] Liang-Chieh Chen, Yukun Zhu, George Papandreou, Florian Schroff, and Hartwig Adam. Encoder-decoder with atrous separable convolution for semantic image segmentation. In ECCV, 2018. 3, 5, 7, 9   \n[19] Yuhui Yuan and Jingdong Wang. Ocnet: Object context network for scene parsing. arXiv, 2018. 3, 8   \n[20] Changqian Yu, Jingbo Wang, Changxin Gao, Gang Yu, Chunhua Shen, and Nong Sang. Context prior for scene segmentation. In CVPR, 2020.   \n[21] Yuhui Yuan, Xilin Chen, and Jingdong Wang. Object-contextual representations for semantic segmentation. arXiv, 2019. 7   \n[22] Hang Zhang, Kristin Dana, Jianping Shi, Zhongyue Zhang, Xiaogang Wang, Ambrish Tyagi, and Amit Agrawal. Context encoding for semantic segmentation. In CVPR, 2018. 7   \n[23] Yizhou Zhou, Xiaoyan Sun, Zheng-Jun Zha, and Wenjun Zeng. Context-reinforced semantic segmentation. In CVPR, 2019.   \n[24] Guosheng Lin, Anton Milan, Chunhua Shen, and Ian Reid. Refinenet: Multi-path refinement networks for high-resolution semantic segmentation. In CVPR, 2017.   \n[25] Rudra PK Poudel, Ujwal Bonde, Stephan Liwicki, and Christopher Zach. Contextnet: Exploring context and detail for semantic segmentation in real-time. arXiv, 2018.   \n[26] Tianyi Wu, Sheng Tang, Rui Zhang, and Yongdong Zhang. Cgnet: A light-weight context guided network for semantic segmentation. arXiv, 2018.   \n[27] Junjun He, Zhongying Deng, Lei Zhou, Yali Wang, and Yu Qiao. Adaptive pyramid context network for semantic segmentation. In CVPR, 2019. 3   \n[28] Henghui Ding, Xudong Jiang, Ai Qun Liu, Nadia Magnenat Thalmann, and Gang Wang. Boundary-aware feature propagation for scene segmentation. In ICCV, 2019. 3   \n[29] Gedas Bertasius, Jianbo Shi, and Lorenzo Torresani. Semantic segmentation with boundary neural fields. In CVPR, 2016.   \n[30] Xiangtai Li, Xia Li, Li Zhang, Guangliang Cheng, Jianping Shi, Zhouchen Lin, Shaohua Tan, and Yunhai Tong. Improving semantic segmentation via decoupled body and edge supervision. arxiv, 2020.   \n[31] Yuhui Yuan, Jingyi Xie, Xilin Chen, and Jingdong Wang. Segfix: Model-agnostic boundary refinement for segmentation. In ECCV, 2020.   \n[32] Mingmin Zhen, Jinglu Wang, Lei Zhou, Shiwei Li, Tianwei Shen, Jiaxiang Shang, Tian Fang, and Long Quan. Joint semantic segmentation and boundary detection using iterative pyramid contexts. In CVPR, 2020.   \n[33] Towaki Takikawa, David Acuna, Varun Jampani, and Sanja Fidler. Gated-scnn: Gated shape cnns for semantic segmentation. In ICCV, 2019. 7   \n[34] Changqian Yu, Jingbo Wang, Chao Peng, Changxin Gao, Gang Yu, and Nong Sang. Learning a discriminative feature network for semantic segmentation. In CVPR, 2018.   \n[35] Liang-Chieh Chen, Jonathan T Barron, George Papandreou, Kevin Murphy, and Alan L Yuille. Semantic image segmentation with task-specific edge detection using cnns and a discriminatively trained domain transform. In CVPR, 2016. 3   \n[36] Jun Fu, Jing Liu, Haijie Tian, Yong Li, Yongjun Bao, Zhiwei Fang, and Hanqing Lu. Dual attention network for scene segmentation. In CVPR, 2019. 3   \n[37] Xiaolong Wang, Ross Girshick, Abhinav Gupta, and Kaiming He. Non-local neural networks. In CVPR, 2018.   \n[38] Zilong Zhong, Zhong Qiu Lin, Rene Bidart, Xiaodan Hu, Ibrahim Ben Daya, Zhifeng Li, Wei-Shi Zheng, Jonathan Li, and Alexander Wong. Squeeze-and-attention networks for semantic segmentation. In CVPR, 2020.   \n[39] Zilong Huang, Xinggang Wang, Lichao Huang, Chang Huang, Yunchao Wei, and Wenyu Liu. Ccnet: Criss-cross attention for semantic segmentation. In ICCV, 2019. 7, 8   \n[40] Hanchao Li, Pengfei Xiong, Jie An, and Lingxue Wang. Pyramid attention network for semantic segmentation. arXiv, 2018.   \n[41] Hengshuang Zhao, Yi Zhang, Shu Liu, Jianping Shi, Chen Change Loy, Dahua Lin, and Jiaya Jia. Psanet: Point-wise spatial attention network for scene parsing. In ECCV, 2018. 8   \n[42] Xia Li, Zhisheng Zhong, Jianlong Wu, Yibo Yang, Zhouchen Lin, and Hong Liu. Expectation-maximization attention networks for semantic segmentation. In ICCV, 2019.   \n[43] Yue Cao, Jiarui Xu, Stephen Lin, Fangyun Wei, and Han Hu. Gcnet: Non-local networks meet squeezeexcitation networks and beyond. In ICCVW, 2019.   \n[44] Enze Xie, Wenjia Wang, Wenhai Wang, Peize Sun, Hang Xu, Ding Liang, and Ping Luo. Segmenting transparent object in the wild with transformer. IJCAI, 2021. 3   \n[45] Albert Shaw, Daniel Hunter, Forrest Landola, and Sammy Sidhu. Squeezenas: Fast neural architecture search for faster semantic segmentation. In ICCVW, 2019. 3   \n[46] Wuyang Chen, Xinyu Gong, Xianming Liu, Qian Zhang, Yuan Li, and Zhangyang Wang. Fasterseg: Searching for faster real-time semantic segmentation. arXiv, 2019.   \n[47] Yanwei Li, Lin Song, Yukang Chen, Zeming Li, Xiangyu Zhang, Xingang Wang, and Jian Sun. Learning dynamic routing for semantic segmentation. In CVPR, 2020.   \n[48] Chenxi Liu, Liang-Chieh Chen, Florian Schroff, Hartwig Adam, Wei Hua, Alan L Yuille, and Li Fei-Fei. Auto-deeplab: Hierarchical neural architecture search for semantic image segmentation. In CPVR, 2019. 7   \n[49] Vladimir Nekrasov, Hao Chen, Chunhua Shen, and Ian Reid. Fast neural architecture search of compact semantic segmentation models via auxiliary cells. In CVPR, 2019. 3   \n[50] Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and Sergey Zagoruyko. End-to-End object detection with transformers. In ECCV, 2020. 3   \n[51] Li Yuan, Yunpeng Chen, Tao Wang, Weihao Yu, Yujun Shi, Zihang Jiang, Francis EH Tay, Jiashi Feng, and Shuicheng Yan. Tokens-to-token vit: Training vision transformers from scratch on imagenet. arXiv, 2021. 3   \n[52] Xiangxiang Chu, Zhi Tian, Bo Zhang, Xinlong Wang, Xiaolin Wei, Huaxia Xia, and Chunhua Shen. Conditional positional encodings for vision transformers. arXiv, 2021. 3, 5   \n[53] Kai Han, An Xiao, Enhua Wu, Jianyuan Guo, Chunjing Xu, and Yunhe Wang. Transformer in transformer. arXiv, 2021. 3   \n[54] Chun-Fu Chen, Quanfu Fan, and Rameswar Panda. Crossvit: Cross-attention multi-scale vision transformer for image classification. arXiv, 2021. 3   \n[55] Yawei Li, Kai Zhang, Jiezhang Cao, Radu Timofte, and Luc Van Gool. Localvit: Bringing locality to vision transformers. arXiv, 2021. 3   \n[56] Haiping Wu, Bin Xiao, Noel Codella, Mengchen Liu, Xiyang Dai, Lu Yuan, and Lei Zhang. Cvt: Introducing convolutions to vision transformers. arXiv, 2021. 3, 5   \n[57] Weijian Xu, Yifan Xu, Tyler Chang, and Zhuowen Tu. Co-scale conv-attentional image transformers. arXiv, 2021. 3   \n[58] Ben Graham, Alaaeldin El-Nouby, Hugo Touvron, Pierre Stock, Armand Joulin, Hervé Jégou, and Matthijs Douze. Levit: a vision transformer in convnet’s clothing for faster inference. arXiv, 2021. 3   \n[59] Peize Sun, Yi Jiang, Rufeng Zhang, Enze Xie, Jinkun Cao, Xinting Hu, Tao Kong, Zehuan Yuan, Changhu Wang, and Ping Luo. Transtrack: Multiple-object tracking with transformer. arXiv, 2020. 3   \n[60] Tim Meinhardt, Alexander Kirillov, Laura Leal-Taixe, and Christoph Feichtenhofer. Trackformer: Multiobject tracking with transformers. arXiv, 2021. 3   \n[61] Hanting Chen, Yunhe Wang, Tianyu Guo, Chang Xu, Yiping Deng, Zhenhua Liu, Siwei Ma, Chunjing Xu, Chao Xu, and Wen Gao. Pre-trained image processing transformer. arXiv, 2020. 3   \n[62] Shuting He, Hao Luo, Pichao Wang, Fan Wang, Hao Li, and Wei Jiang. Transreid: Transformer-based object re-identification. arXiv, 2021. 3   \n[63] Manoj Kumar, Dirk Weissenborn, and Nal Kalchbrenner. Colorization transformer. arXiv, 2021. 3   \n[64] Alaaeldin El-Nouby, Natalia Neverova, Ivan Laptev, and Hervé Jégou. Training vision transformers for image retrieval. arXiv, 2021. 3   \n[65] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. arXiv, 2021. 3   \n[66] Ronghang Hu and Amanpreet Singh. Transformer is all you need: Multimodal multitask learning with a unified transformer. arXiv, 2021. 3   \n[67] Md Amirul Islam, Sen Jia, and Neil DB Bruce. How much position information do convolutional neural networks encode? arXiv, 2020. 4, 5   \n[68] Wenjie Luo, Yujia Li, Raquel Urtasun, and Richard Zemel. Understanding the effective receptive field in deep convolutional neural networks. arXiv, 2017. 5   \n[69] Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The cityscapes dataset for semantic urban scene understanding. In CVPR, 2016. 6, 8   \n[70] Bolei Zhou, Hang Zhao, Xavier Puig, Sanja Fidler, Adela Barriuso, and Antonio Torralba. Scene parsing through ade20k dataset. In CVPR, 2017. 6, 8   \n[71] Holger Caesar, Jasper Uijlings, and Vittorio Ferrari. Coco-stuff: Thing and stuff classes in context. In CVPR, 2018. 6, 8   \n[72] Huiyu Wang, Yukun Zhu, Bradley Green, Hartwig Adam, Alan L. Yuille, and Liang-Chieh Chen. Axialdeeplab: Stand-alone axial-attention for panoptic segmentation. In ECCV, 2020. 7, 8   \n[73] Yanwei Li, Lin Song, Yukang Chen, Zeming Li, Xiangyu Zhang, Xingang Wang, and Jian Sun. Learning dynamic routing for semantic segmentation. In CVPR, 2020.   \n[74] Gerhard Neuhold, Tobias Ollmann, Samuel Rota Bulò, and Peter Kontschieder. The mapillary vistas dataset for semantic understanding of street scenes. In ICCV, 2017. 9   \n[75] Christoph Kamann and Carsten Rother. Benchmarking the robustness of semantic segmentation models. In CVPR, 2020. 9 ",
+        "bbox": [
+            176,
+            251,
+            826,
+            917
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            56,
+            828,
+            912
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            73,
+            828,
+            914
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            828,
+            527
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            554,
+            254,
+            570
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            580,
+            339,
+            594
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] Please Section 5.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] Please see Broader Impact.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            598,
+            825,
+            704
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            708,
+            493,
+            722
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            236,
+            727,
+            736,
+            757
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            762,
+            393,
+            776
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] We observed quite stable mIoU results for semantic segmentation models.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] ",
+        "bbox": [
+            238,
+            780,
+            825,
+            912
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            214,
+            90,
+            825,
+            106
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] Please see Section 4.   \n(b) Did you mention the license of the assets? [Yes] The data used in our work is open source and can be used for adademic research.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We provide our code for this work in the supplemental material.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] The data used in our work is open source and can be used for adademic research.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] The data does not contain personally identifiable information or offensive content. ",
+        "bbox": [
+            238,
+            109,
+            825,
+            272
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            276,
+            705,
+            291
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            296,
+            825,
+            386
+        ],
+        "page_idx": 13
+    }
+]

parse/train/OsBM0sWwn_-/OsBM0sWwn_-.md

@@ -0,0 +1,358 @@
+# baller2vec: A Multi-Entity Transformer For Multi-Agent Spatiotemporal Modeling
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Multi-agent spatiotemporal modeling is a challenging task from both an algorithmic   
+2 design and computational complexity perspective. Recent work has explored the   
+3 efficacy of traditional deep sequential models in this domain, but these architectures   
+4 are slow and cumbersome to train, particularly as model size increases. Further,   
+5 prior attempts to model interactions between agents across time have limitations,   
+6 such as imposing an order on the agents, or making assumptions about their relation  
+7 ships. In this paper, we introduce baller2vec1, a multi-entity generalization of   
+8 the standard Transformer that can, with minimal assumptions, simultaneously and   
+9 efficiently integrate information across entities and time. We test the effectiveness   
+10 of baller2vec for multi-agent spatiotemporal modeling by training it to perform   
+11 two different basketball-related tasks: (1) simultaneously modeling the trajectories   
+12 of all players on the court and (2) modeling the trajectory of the ball. Not only does   
+13 baller2vec learn to perform these tasks well (outperforming a graph recurrent   
+14 neural network with a similar number of parameters by a wide margin), it also   
+15 appears to “understand” the game of basketball, encoding idiosyncratic qualities of   
+16 players in its embeddings, and performing basketball-relevant functions with its   
+17 attention heads.
+
+# 18 1 Introduction
+
+19 Whether it is a defender anticipating where the point guard will make a pass in a game of basketball,   
+20 a marketing professional guessing the next trending topic on a social media platform, or a theme   
+21 park manager forecasting the flow of visitor traffic, humans frequently attempt to predict phenomena   
+22 arising from processes involving multiple entities interacting through time. When designing learning   
+23 algorithms to perform such tasks, researchers face two main challenges:
+
+1. Given that entities lack a natural ordering, how do you effectively model interactions between entities across time?   
+2. How do you efficiently learn from the large, high-dimensional inputs inherent to such sequential data?
+
+Prior work in athlete trajectory modeling, a widely studied application of multi-agent spatiotemporal modeling (MASM; where entities are agents moving through space), has attempted to model player interactions through “role-alignment” preprocessing steps (i.e., imposing an order on the players) [1, 2] or graph neural networks [3], but these approaches may destroy identity information in the former case (see Section 4.2) or limit personalization in the latter case (see Section 5.1). Recently, researchers have experimented with variational recurrent neural networks (VRNNs) [4] to model
+
+34 the temporal aspects of player trajectory data [3, 2], but the inherently sequential design of this   
+35 architecture limits the size of models that can feasibly be trained in experiments.   
+36 Transformers [5] were designed to circumvent the computational constraints imposed by other   
+37 sequential models, and they have achieved state-of-the-art results in a wide variety of sequence   
+38 learning tasks, both in natural language processing (NLP), e.g., GPT-3 [6], and computer vision, e.g.,   
+39 Vision Transformers [7]. While Transformers have successfully been applied to static multi-entity   
+40 data, e.g., graphs [8], the only published work we are aware of that attempts to model multi-entity   
+41 sequential data with Transformers uses four different Transformers to separately process information   
+42 temporally and spatially before merging the sub-Transformer outputs [9].
+
+![](images/f9d9a840f11cf317947cc865472857e870a7cb57ba6e388aacea3ee8591c3f79.jpg)  
+Figure 1: After solely being trained to model the trajectory of the ball ( ) given the locations of the players and the ball on the court through time, a self-attention (SA) head in baller2vec learned to anticipate passes. When the ball handler $( \bullet \circ )$ is driving towards the basket at $t \ : = \ : 4$ , SA assigns near-zero weights (black) to all players, suggesting no passes will be made. Indeed, the ball handler did not pass and dribbled into the lane $( t = 8 )$ ). SA then assigns a high weight (white) to a teammate $\left( \sqsupset \right)$ , which correctly identifies the recipient of the pass at $t = 1 3$ .
+
+In this paper, we introduce a multientity Transformer that, with minimal assumptions, is capable of simultaneously integrating information across agents and time, which gives it powerful representational capabilities. We adapt the original Transformer architecture to suit multi-entity sequential data by converting the standard self-attention mask matrix used in NLP tasks into a novel self-attention mask tensor. To test the effectiveness of our multi-entity Transformer for MASM, we train it to perform two different basketball-related tasks (hence the name baller2vec): (1) simultaneously modeling the trajectories of all players on the court (Task P) and (2) modeling the trajectory of the ball
+
+(Task B). Further, we convert these tasks into classification problems by binning the Euclidean trajectory space, which allows baller2vec to learn complex, multimodal trajectory distributions via strictly maximizing the likelihood of the data (in contrast to variational approaches, which maximize the evidence lower bound and thus require priors over the latent variables). We find that:
+
+1. baller2vec is an effective learning algorithm for MASM, obtaining a perplexity of 1.64 on Task P (compared to 15.72 when simply using the label distribution from the training set) and 13.44 on Task B (vs. 316.05) (Section 4.1). Further, compared to a graph recurrent neural network (GRNN) with similar capacity, baller2vec is ${ \sim } 3 . 8$ times faster and achieves a $1 0 . 5 \%$ lower average negative log-likelihood (NLL) on Task P (Section 4.1).
+
+2. baller2vec demonstrably integrates information across both agents and time to achieve these results, as evidenced by ablation experiments (Section 4.2).
+
+3. The identity embeddings learned by baller2vec capture idiosyncratic qualities of players, indicative of the model’s deep personalization capabilities (Section 4.3).
+
+4. baller2vec’s trajectory bin distributions depend on both the historical and current context (Section 4.4), and several attention heads appear to perform different basketball-relevant functions (Figure 1; Section 4.5), which suggests the model learned to “understand” the sport.
+
+# 2 Methods
+
+# 2.1 Multi-entity sequences
+
+Let $A = \{ 1 , 2 , \dots , B \}$ be a set indexing $B$ entities and $P = \{ p _ { 1 } , p _ { 2 } , . . . , p _ { K } \} \subset A$ be the $K$ entities involved in a particular sequence. Further, let $Z _ { t } = \{ z _ { t , 1 } , z _ { t , 2 } , \dots , z _ { t , K } \}$ be an unordered set of $K$ feature vectors such that $z _ { t , k }$ is the feature vector at time step $t$ for entity $p _ { k }$ . $\mathcal { Z } = ( Z _ { 1 } , Z _ { 2 } , . . . , Z _ { T } )$ is thus an ordered sequence of sets of feature vectors over $T$ time steps. When $K = 1$ , $\mathcal { Z }$ is a sequence of individual feature vectors, which is the underlying data structure for many NLP problems.
+
+86 We now consider two different tasks: (1) sequential entity labeling, where each entity has its own label   
+87 at each time step (which is conceptually similar to word-level language modeling), and (2) sequential   
+88 labeling, where each time step has a single label (see Figure 3). For (1), let $\mathcal { V } = ( V _ { 1 } , V _ { 2 } , \ldots , V _ { T } )$ be   
+89 a sequence of sets of labels corresponding to $\mathcal { Z }$ such that $V _ { t } = \{ v _ { t , 1 } , v _ { t , 2 } , \ldots , v _ { t , K } \}$ and $v _ { t , k }$ is the   
+90 label at time step $t$ for the entity indexed by $k$ . For (2), let $W = ( w _ { 1 } , w _ { 2 } , \dots , w _ { T } )$ be a sequence of   
+91 labels corresponding to $\mathcal { Z }$ where $w _ { t }$ is the label at time step $t$ . The goal is then to learn a function $f$   
+92 that maps a set of entities and their time-dependent feature vectors $\mathcal { Z }$ to a probability distribution   
+93 over either (1) the entities’ time-dependent labels $\nu$ or (2) the sequence of labels $W$ .
+
+# 94 2.2 Multi-agent spatiotemporal modeling
+
+95 In the MASM setting, $P$ is a set of $K$ different agents and   
+96 $C _ { t } = \{ ( x _ { t , 1 } , y _ { t , 1 } ) , ( \bar { x } _ { t , 2 } , y _ { t , 2 } ) , \ldots , ( x _ { t , K } , y _ { t , K } ) \bar  \}$ is an un  
+97 ordered set of $K$ coordinate pairs such that $( x _ { t , k } , y _ { t , k } )$ are   
+98 the coordinates for agent $p _ { k }$ at time step $t$ . The ordered   
+99 sequence of sets of coordinates $\mathcal { C } = ( \bar { C } _ { 1 } , C _ { 2 } , \ldots , C _ { T } )$ ,   
+00 together with $P$ , thus defines the trajectories for the   
+101 $K$ agents over $T$ time steps. We then define $z _ { t , k }$ as:   
+102 $z _ { t , k } \stackrel { - } { = } g ( [ e ( p _ { k } ) , x _ { t , k } , y _ { t , k } , \stackrel { - } { h _ { t , k } } ] )$ , where $g$ is a multilayer   
+103 perceptron (MLP), $e$ is an agent embedding layer, and $h _ { t , k }$   
+104 is a vector of optional contextual features for agent $p _ { k }$ at   
+105 time step $t$ . The trajectory for agent $p _ { k }$ at time step $t$ is   
+106 defined as $( x _ { t + 1 , k } - x _ { t , k } , y _ { t + 1 , k } - y _ { t , k } )$ . Similar to Zheng   
+107 et al. [10], to fully capture the multimodal nature of the   
+08 trajectory distributions, we binned the 2D Euclidean space   
+109 into an $n \times n$ grid (Figure 2) and treated the problem as a classification task. Therefore, $\mathcal { Z }$ has a cor  
+110 responding sequence of sets of trajectory labels (i.e., $v _ { t , k } = \mathrm { B i n } ( \Delta x _ { t , k } , \Delta y _ { t , k } )$ , so $v _ { t , k }$ is an integer   
+111 from one to $n ^ { 2 }$ ), and the loss for each sample in Task $\mathbf { P }$ is: $\begin{array} { r } { \mathcal { L } = \sum _ { t = 1 } ^ { T } \sum _ { k = 1 } ^ { K } - \ln ( f ( \mathcal { Z } ) _ { t , k } [ v _ { t , k } ] ) } \end{array}$   
+112 where $f ( \mathcal { Z } ) _ { t , k } [ v _ { t , k } ]$ is the probability assigned to the trajectory label for agent $p _ { k }$ at time step $t$ by $f$ ;   
+113 i.e., the loss is the NLL of the data according to the model.   
+114 For Task $\mathbf { B }$ , the loss for each sample is: $\begin{array} { r } { \mathcal { L } = \sum _ { t = 1 } ^ { T } - \ln ( f ( \mathcal { Z } ) _ { t } [ w _ { t } ] ) } \end{array}$ , where $f ( \mathcal { Z } ) _ { t } [ \boldsymbol { w } _ { t } ]$ is the   
+115 probability assigned to the trajectory label for the ball at time step $t$ by $f$ , and the labels correspond   
+116 to a binned 3D Euclidean space (i.e., $w _ { t } = \mathrm { B i n } ( \Delta x _ { t } , \Delta y _ { t } , \Delta z _ { t } )$ , so $w _ { t }$ is an integer from one to $n ^ { 3 }$ ).   
+118 We now describe our multi-entity   
+119 Transformer, baller2vec (Figure 3).   
+120 For NLP tasks, the Transformer self  
+121 attention mask $M$ takes the form of a   
+122 $T \times T$ matrix (Figure 4) where $T$ is   
+123 the length of the sequence. The ele  
+124 ment at $M _ { t _ { 1 } , t _ { 2 } }$ thus indicates whether   
+125 or not the model can “look” at time   
+126 step $t _ { 2 }$ when processing time step   
+127 $t _ { 1 }$ . Here, we generalize the stan  
+128 dard Transformer to the multi-entity   
+129 setting by employing a $T \times K \times$   
+130 $T \times K$ mask tensor where element   
+131 $M _ { t _ { 1 } , k _ { 1 } , t _ { 2 } , k _ { 2 } }$ indicates whether or not   
+132 the model can “look” at agent ${ { p } _ { k _ { 2 } } }$ at   
+133 time step $t _ { 2 }$ when processing agent   
+134 $p _ { k _ { 1 } }$ at time step $t _ { 1 }$ . Here, we mask   
+135 all elements where $t _ { 2 } > t _ { 1 }$ and leave   
+136 all remaining elements unmasked, i.e.,   
+137 baller2vec is a “causal” model.   
+138 In practice, to be compatible with Transformer implementations in major deep learning libraries,   
+139 we reshape $M$ into a $T K \times T K$ matrix (Figure 4), and the input to the Transformer is a matrix   
+140 with shape $T K \times F$ where $F$ is the dimension of each $z _ { t , k }$ . Irie et al. [11] observed that positional   
+141 encoding [5] is not only unnecessary, but detrimental for Transformers that use a causal attention   
+142 mask, so we do not use positional encoding with baller2vec. The remaining computations are   
+143 identical to the standard Transformer (see code).
+
+![](images/847eca0e9d29292771dadd98447cc88a9693ed7cbbe63daf4dc3437e54f8c767.jpg)  
+Figure 2: An example of a binned trajectory. The agent’s starting position is at the center of the grid, and the cell containing the agent’s ending position is used as the label (of which there are $n ^ { 2 }$ possibilities).
+
+![](images/d2c14159ab29fd5262ac92136e774591ebc66e2e94a3211eee68c647a9d42c6a.jpg)  
+Figure 3: An overview of our multi-entity Transformer, baller2vec. Each time step $t$ consists of an unordered set $Z _ { t }$ of entity feature vectors (colored circles) as the input, with either (left) a corresponding set $V _ { t }$ of entity labels (colored diamonds) or (right) a single label $w _ { t }$ (gray triangle) as the target. Matching colored circles/diamonds across time steps correspond to the same entity. In our experiments, each entity feature vector $z _ { t , k }$ is produced by an MLP $g$ that takes a player’s identity embedding $e ( p _ { k } )$ , raw court coordinates $( x _ { t , k } , y _ { t , k } )$ , and a binary variable indicating the player’s frontcourt $h _ { t , k }$ as input. Each entity label $v _ { t , k }$ is an integer indexing the trajectory bin derived from the player’s raw trajectory, while each $w _ { t }$ is an integer indexing the ball’s trajectory bin.
+
+![](images/298f2bcb2493ccbe12780271785c406d40208b6be2c23a9fde161e8519c7f386.jpg)  
+Figure 4: Left: the standard self-attention mask matrix $M$ . The element at $M _ { t _ { 1 } , t _ { 2 } }$ indicates whether or not the model can “look” at time step $t _ { 2 }$ when processing time step $t _ { 1 }$ . Right: the matrix form of our multi-entity self-attention mask tensor. In tensor form, element $M _ { t _ { 1 } , k _ { 1 } , t _ { 2 } , k _ { 2 } }$ indicates whether or not the model can “look” at agent $p _ { k _ { 2 } }$ at time step $t _ { 2 }$ when processing agent $p _ { k _ { 1 } }$ at time step $t _ { 1 }$ . In matrix form, this corresponds to element $M _ { t _ { 1 } K + k _ { 1 } , t _ { 2 } K + k _ { 2 } }$ when using zerobased indexing. The $M$ shown here is for a static, fully connected graph, but other, potentially evolving network structures can be encoded in the attention mask tensor.
+
+# 3 Experiments
+
+# 3.1 Dataset
+
+We trained baller2vec on a publicly available dataset of player and ball trajectories recorded from 631 National Basketball Association (NBA) games from the 2015-2016 season.2 All 30 NBA teams and 450 different players were represented. Because transition sequences are a strategically important part of basketball, unlike prior work, e.g., Felsen et al. [1], Yeh et al. [3], Zhan et al. [2], we did not terminate sequences on a change of possession, nor did we constrain ourselves to a fixed subset of sequences. Instead, each training sample was generated on the fly by first randomly sampling a game, and then randomly sampling a starting time from that game. The following four seconds of data were downsampled to $5 \mathrm { H z }$ from the original $2 5 \ : \mathrm { H z }$ and used as the input.
+
+Because we did not terminate sequences on a change of possession, we could not normalize the direction of the court as was done in prior work [1, 3, 2]. Instead, for each sampled sequence, 56 we randomly (with a probability of 0.5) rotated the court $1 8 0 ^ { \circ }$ (because the court’s direction is arbitrary), doubling the size of the dataset. We used a training/validation/test split of 569/30/32 58 games, respectively (i.e., $5 \%$ of the games were used for testing, and $5 \%$ of the remaining $9 5 \%$ 59 of games were used for validation). As a result, we had access to ${ \sim } 8 2$ million different (albeit 0 overlapping) training sequences (569 games $\times 4$ periods per game $\times \ 1 2$ minutes per period $\times 6 0$ seconds per minute $\times 2 5 \mathrm { H z } \times 2$ rotations), ${ \sim } 8 0 0 \mathrm { x }$ the number of sequences used in prior work. 2 For both the validation and test sets, $\mathord { \sim } 1 , 0 0 0$ different, non-overlapping sequences were selected for 3 evaluation by dividing each game into $\lceil \frac { 1 , 0 0 0 } { N } \rceil$ non-overlapping chunks (where $N$ is the number of games), and using the starting four seconds from each chunk as the evaluation sequence.
+
+# 3.2 Model
+
+We trained separate models for Task $\mathbf { P }$ and Task B. For all experiments, we used a single Transformer architecture that was nearly identical to the original model described in Vaswani et al. [5], with $d _ { \mathrm { m o d e l } } = 5 1 2$ (the dimension of the input and output of each Transformer layer), eight attention heads,
+
+169 $d _ { \mathrm { f f } } = 2 0 4 8$ (the dimension of the inner feedforward layers), and six layers, although we did not use   
+170 dropout. For both Task $\mathbf { P }$ and Task $\mathbf { B }$ , the players and the ball were included in the input, and both   
+171 the players and the ball were embedded to 20-dimensional vectors. The input features for each player   
+172 consisted of his identity, his $( x , y )$ coordinates on the court at each time step in the sequence, and a   
+173 binary variable indicating the side of his frontcourt (i.e., the direction of his team’s hoop).3 The input   
+174 features for the ball were its $( x , y , z )$ coordinates at each time step.   
+175 The input features for the players and the ball were processed by separate, three-layer MLPs before   
+176 being fed into the Transformer. Each MLP had 128, 256, and 512 nodes in its three layers, respectively,   
+177 and a ReLU nonlinearity following each of the first two layers. For classification, a single linear layer   
+178 was applied to the Transformer output followed by a softmax. For players, we binned an $1 1 \mathrm { f t } \times 1 1$ ft   
+179 2D Euclidean trajectory space into an $1 1 \times 1 1$ grid of $1 \mathrm { f t } \times 1$ ft squares for a total of 121 player   
+180 trajectory labels. Similarly, for the ball, we binned a $1 9 \ : \mathrm { f t } \times 1 9$ ft $\times 1 9$ ft 3D Euclidean trajectory   
+181 space into a $1 9 \times 1 9 \times 1 9$ grid of $1 \mathrm { f t } \times 1$ ft $\times 1$ ft cubes for a total of 6,859 ball trajectory labels.   
+182 We used the Adam optimizer [12] with an initial learning rate of $1 0 ^ { - 6 }$ , $\beta _ { 1 } = 0 . 9$ , $\beta _ { 2 } = 0 . 9 9 9$ , and   
+183 $\epsilon = 1 0 ^ { - 9 }$ to update the model’s parameters, of which there were ${ \sim } 1 9 / 2 3$ million for Task P/Task B,   
+184 respectively. The learning rate was reduced to $1 0 ^ { - 7 }$ after 20 consecutive epochs of the validation loss   
+185 not improving. Models were implemented in PyTorch and trained on a single NVIDIA GTX $1 0 8 0 \mathrm { T i }$   
+186 GPU for seven days $\mathord { \sim } 6 5 0$ epochs) where each epoch consisted of 20,000 training samples, and the   
+187 validation set was used for early stopping.
+
+# 3.3 Baselines
+
+89 As our naive baseline, we used the marginal distribution of   
+90 the trajectory bins from the training set for all predictions.   
+91 For our strong baseline, we implemented a baller2vec  
+92 like graph recurrent neural network (GRNN) and trained   
+93 it on Task P (code is available in the baller2vec repos  
+94 itory).4 Specifically, at each time step, the player and ball   
+95 inputs were first processed using MLPs as in baller2vec,   
+96 and these inputs were then fed into a graph neural net  
+97 work (GNN) similar to Yeh et al. [3]. The node and   
+98 edge functions of the GNN were each a Transformer  
+99 like feedforward network (TFF), i.e., $\mathrm { T F F } ( x ) = \mathrm { L N } ( x +$   
+00 $W _ { 2 } \mathrm { R e L U } ( W _ { 1 } x + b _ { 1 } ) + b _ { 2 } )$ , where LN is Layer Normal  
+01 ization [13], $W _ { 1 }$ and $W _ { 2 }$ are weight matrices, $b _ { 1 }$ and $b _ { 2 }$
+
+Table 1: The perplexity per trajectory bin on the test set when using baller2vec vs. the marginal distribution of the trajectory bins in the training set (“Train”) for all predictions. baller2vec considerably reduces the uncertainty over the trajectory bins.
+
+<table><tr><td colspan="2">baller2vec</td><td>Train</td></tr><tr><td>Task P</td><td>1.64</td><td>15.72</td></tr><tr><td>Task B</td><td>13.44</td><td>316.05</td></tr></table>
+
+02 are bias vectors, and ReLU is the rectifier activation function. For our RNN, we used a gated recurrent   
+203 unit (GRU) RNN [14] in which we replaced each of the six weight matrices of the GRU with a TFF.   
+04 Each TFF had the same dimensions as the Transformer layers used in baller2vec. Our GRNN had   
+205 ${ \sim } 1 8 \mathbf { M }$ parameters, which is comparable to the ${ \sim } 1 9 \mathbf { M }$ in baller2vec. We also trained our GRNN   
+206 for seven days ${ \sim } 1 7 5$ epochs).
+
+# 3.4 Ablation studies
+
+To assess the impacts of the multi-entity design and player embeddings of baller2vec on model performance, we trained three variations of our Task $\mathbf { P }$ model using: (1) one player in the input without player identity, (2) all 10 players in the input without player identity, and (3) all 10 players in the input with player identity. In experiments where player identity was not used, a single generic player embedding was used in place of the player identity embeddings. We also trained two variations of our Task B model: one with player identity and one without. Lastly, to determine the extent to which baller2vec uses historical information in its predictions, we compared the performance of our best Task P model on the full sequence test set with its performance on the test set when only predicting the trajectories for the first frame (i.e., we applied the same model to only the first frames of the test set).
+
+# 4.1 baller2vec is an effective learning algorithm for multi-agent spatiotemporal modeling.
+
+The average NLL on the test set for our best Task $\mathbf { P }$ model was 0.492, while the average NLL for our best Task B model was 2.598. In NLP, model performance is often expressed in terms of the perplexity per word, which, intuitively, is the number of faces on a fair die that has the same amount of uncertainty as the model per word (i.e., a uniform distribution over $M$ labels has a perplexity of $M$ , so a model with a per word perplexity of six has the same average uncertainty as rolling a fair six-sided die). In our case, we con
+
+Table 2: The average NLL (lower is better) on the Task $\mathbf { P }$ test set and seconds per training epoch (SPE) for baller2vec (b2v) and our GRNN. baller2vec trains ${ \sim } 3 . 8$ times faster per epoch compared to our GRNN, and baller2vec outperformed our GRNN by $1 0 . 5 \%$ when given the same amount of training time. Even when only allowed to train for half $( ^ { 6 6 } 0 . 5 \mathrm { x } ^ { 7 } )$ and a quarter $( ^ { 6 4 } 0 . 2 5 \mathrm { x } ^ { 3 7 } )$ as long as our GRNN, baller2vec outperformed our GRNN by $9 . 1 \%$ and $1 . 5 \%$ , respectively..
+
+<table><tr><td></td><td>b2v</td><td>b2v (0.5x)</td><td>b2v (0.25x)</td><td>GRNN</td></tr><tr><td>NLL</td><td>0.492</td><td>0.499</td><td>0.541</td><td>0.549</td></tr><tr><td>SPE</td><td>~900</td><td>~900</td><td>~900</td><td>~3,400</td></tr></table>
+
+sider the perplexity per trajectory bin, defined as: $\begin{array} { r } { P P = e ^ { \frac { 1 } { N T K } } \sum _ { n = 1 } ^ { N } \sum _ { t = 1 } ^ { T } \sum _ { k = 1 } ^ { K } - \ln ( p ( v _ { n , t , k } ) ) } \end{array}$ , where $N$ is the number of sequences. Our best Task $\mathbf { P }$ model achieved a $P P$ of 1.64, i.e., baller2vec was, on average, as uncertain as rolling a 1.64-sided fair die (better than a coin flip) when predicting player trajectory bins (Table 1). For comparison, when using the distribution of the player trajectory bins in the training set as the predicted probabilities, the $P P$ on the test set was 15.72. Our best Task B model achieved a $P P$ of 13.44 (compared to 316.05 when using the training set distribution).
+
+Compared to our GRNN, baller2vec was ${ \sim } 3 . 8$ times faster and had a $1 0 . 5 \%$ lower average NLL when given an equal amount of training time (Table 2). Even when only given half as much training time as our GRNN, baller2vec had a $9 . 1 \%$ lower average NLL.
+
+# 4.2 baller2vec uses information about all players on the court through time, in addition to player identity, to model spatiotemporal dynamics.
+
+Results for our ablation experiments can be seen in Table 3. Including all 10 players in the input dramatically improved the performance of our Task P model by $1 8 . 0 \%$ vs. only including a single player. Including player identity improved the model’s performance a further $4 . 4 \%$ . This stands in contrast to Felsen et al. [1] where the inclusion of player identity led to slightly worse model performance; a counterintuitive result given the range of skills among NBA players, but possibly a side effect of their rolealignment procedure. Additionally, when replacing the players in each test set sequence with random players, the performance of our best Task P model deteriorated by $6 . 2 \%$ from 0.492 to 0.522. Interestingly, including player identity only improved our Task B model’s performance by $2 . 7 \%$ . Lastly, our best Task $\mathbf { P }$ model’s performance on the full sequence test set
+
+Table 3: The average NLL on the test set for each of the models in our ablation experiments (lower is better). For Task P, using all 10 players improved model performance by $1 8 . 0 \%$ , while using player identity improved model performance by an additional $4 . 4 \%$ . For Task B, using player identity improved model performance by $2 . 7 \%$ . 1/10 indicates whether one or 10 players were used as input, respectively, while I/NI indicates whether or not player identity was used, respectively.
+
+<table><tr><td>Task</td><td>1-NI 10-NI</td><td>10-1</td></tr><tr><td>Task P</td><td>0.628 0.515</td><td>0.492</td></tr><tr><td>Task B</td><td>N/A 2.670</td><td>2.598</td></tr></table>
+
+(0.492) was $7 0 . 6 \%$ better than its performance on the single frame test set (1.67), i.e., baller2vec is clearly using historical information to model the spatiotemporal dynamics of basketball.
+
+# 65 4.3 baller2vec’s learned player embeddings encode individual attributes.
+
+Neural language models are widely known for their ability to encode semantic relationships between words and phrases as geometric relationships between embeddings—see, e.g., Mikolov et al. [16, 17], Le and Mikolov [18], Sutskever et al. [19]. Alcorn [20] observed a similar phenomenon in a baseball setting, where batters and pitchers with similar skills were found next to each other in the
+
+![](images/78a776bc2ff86bfe2bdfde6df160c8840f679871731d048ca55fb87d9ebbcab9.jpg)  
+Figure 5: As can be seen in this 2D UMAP of the player embeddings, by exclusively learning to predict the trajectory of the ball, baller2vec was able to infer idiosyncratic player attributes. The left-hand side of the plot contains tall post players $( \neg , \sqsupset )$ , e.g., Serge Ibaka, while the right-hand side of the plot contains shorter shooting guards $( \frac { \lambda } { 2 5 } )$ and point guards $( + )$ , e.g., Stephen Curry. The connecting transition region contains forwards $( \sqsubseteq , \bigcirc )$ and other “hybrid” players, i.e., individuals possessing both guard and post skills, e.g., LeBron James. Further, players with similar defensive abilities, measured here by the cube root of the players’ blocks per minute in the 2015-2016 season [15], cluster together.
+
+270 embedding space learned by a neural network trained to predict the outcome of an at-bat. A 2D   
+271 UMAP [21] of the player embeddings learned by baller2vec for Task B can be seen in Figure 5.   
+272 Like (batter|pitcher)2vec [20], baller2vec seems to encode skills and physical attributes in   
+273 its player embeddings.
+
+Querying the nearest neighbors for individual players reveals further insights about the baller2vec embeddings. For example, the nearest neighbor for Russell Westbrook, an extremely athletic $6 3 "$ point guard, is Derrick Rose, a $6 2 "$ point guard also known for his athleticism. Amusingly, the nearest neighbor for Pau Gasol, a 7’1" center with a respectable shooting range, is his younger brother Marc Gasol, a $6 7 1 1 "$ center, also with a respectable shooting range.
+
+![](images/d9f498eb7c6fa700f87e0a7514776c4598e51d13690973e09e4f71aabc938d2d.jpg)  
+Figure 6: baller2vec’s trajectory predicted trajectory bin distributions are affected by both the historical and current context. At $t ~ = ~ 1$ , baller2vec is fairly uncertain about the target player’s ( ; $k = 8$ ) trajectory (left grid and dotted red line; the blue-bordered center cell is the “stationary” trajectory), with most of the probability mass divided between trajectories moving towards the ball handler’s sideline (right grid; black $= 1 . 0$ ; white $= 0 . 0$ ). After observing a portion of the sequence $\mathit { t } = 6 $ ), baller2vec becomes very certain about the target player’s trajectory $( f _ { 6 , 8 } )$ , but when the player reaches a decision point $\mathit { t } = 1 3$ ), baller2vec becomes split between trajectories (staying still or moving towards the top of the key). Additional examples can be found in Figure S1. $\mathrm { { O } = \ b a l l }$ , $\sqsubset =$ offense, $\Delta =$ defense, and $f _ { t , k } = f ( \mathcal { Z } ) _ { t , k }$ .
+
+# 4.4 baller2vec’s predicted trajectory bin distributions depend on both the historical and current context.
+
+Because baller2vec explicitly models the distribution of the player trajectories (unlike variational methods), we can easily visualize how its predicted trajectory bin distributions shift in different situations. As can be seen in Figure 6, baller2vec’s predicted trajectory bin distributions depend on both the historical and current context. When provided with limited historical information, baller2vec tends to be less certain about where the players might go. baller2vec also tends to be more certain when predicting trajectory bins at “easy” moments (e.g., a player moving into open space) vs. “hard” moments (e.g., an offensive player choosing which direction to move around a defender).
+
+One intriguing property of the attention mechanism [22–25] is how, when visualized, the attention weights often seem to reveal how a model is “thinking”. For example, Vaswani et al. [5] discovered examples of attention heads in their Transformer that appear to be performing various language understanding subtasks, such as anaphora resolution. As can be seen in Figure 7, some of the attention heads in baller2vec seem to be performing basketball understanding subtasks, such as keeping track of the ball handler’s teammates, and anticipating who the ball handler will pass to, which, intuitively, help with our task of predicting the ball’s trajectory.
+
+# 5 Related Work
+
+# 5.1 Trajectory modeling in sports
+
+There is a rich literature on MASM, particularly in the context of sports, e.g., Kim et al. [26], Zheng et al. [10], Le et al. [27, 28], Qi et al. [29], Zhan et al. [30]. Most relevant to our work is Yeh et al. [3], who used a variational recurrent neural network combined with a graph neural
+
+![](images/71634d4f5d6c0f7b7fb066cfa62f54482eded9f138e6750c33eb669a9bb6d4ba.jpg)  
+Figure 7: The attention outputs from baller2vec suggest it learned basketball-relevant functions. Left: attention head 2-7 (layer-head) appears to focus on teammates of the ball handler $( \infty )$ . Middle and right: attention head 6-2 seems to predict (middle; ) who the ball handler will be in a future frame (right). Players are shaded according to the sum of the attention weights assigned to the players through time with reference to the ball in the current frame (recall that each player occurs multiple times in the input). Higher attention weights are lighter. For both of these attention heads, the sum of the attention weights assigned to the ball through time was small (0.01 for both the left and middle frames where the maximum is 1.00). Additional examples can be found in Figures S2 and S3.
+
+network to forecast trajectories in a multi-agent setting. Like their approach, our model is permutation equivariant with regard to the ordering of the agents; however, we use a multi-head attention mechanism to achieve this permutation equivariance while the permutation equivariance in Yeh et al. [3] is provided by the graph neural network. Specifically, Yeh et al. [3] define: $v  e : { \bf e } _ { i , j } =$ $f _ { e } \big ( \big [ \mathbf { v } _ { i } , \mathbf { v } _ { j } , \mathbf { t } _ { i , j } \big ] \big )$ and $\begin{array} { r } { e  \bar { v ^ { } } : { \mathbf { 0 } } _ { i } = f _ { v } ( \sum _ { j \in \mathcal { N } _ { i } } [ \mathbf { e } _ { i , j } , \mathbf { t } _ { i } ] ) } \end{array}$ , where ${ \bf v } _ { i }$ is the initial state of agent $i$ , $\mathbf { t } _ { i , j }$ is an embedding for the edge between agents $i$ and $j$ , $\mathbf { e } _ { i , j }$ is the representation for edge $( i , j )$ , ${ \mathcal { N } } _ { i }$ is the neighborhood for agent $i$ , $\mathbf { t } _ { i }$ is a node embedding for agent $i$ , $\mathbf { o } _ { i }$ is the output state for agent $i$ , and $f _ { e }$ and $f _ { v }$ are deep neural networks.
+
+Assuming each individual player is a different “type” in $f _ { e }$ (i.e., attempting to maximize the level of personalization) would require $4 5 0 ^ { 2 } = 2 0 2 { , } 5 0 0$ (i.e., $B ^ { 2 }$ ) different $t _ { i , j }$ edge embeddings, many of which would never be used during training and thus inevitably lead to poor out-of-sample performance. Reducing the number of type embeddings requires making assumptions about the nature of the relationships between nodes. By using a multi-head attention mechanism, baller2vec learns to integrate information about different agents in a highly flexible manner that is both agent and timedependent, and can generalize to unseen agent combinations. The attention heads in baller2vec are somewhat analogous to edge types, but, importantly, they do not require a priori knowledge about the relationships between the players.
+
+Additionally, unlike recent works that use variational methods to train their generative models [3, 1, 2], we translate the multi-agent trajectory modeling problem into a classification task, which allows us to train our model by strictly maximizing the likelihood of the data. As a result, we do not make any assumptions about the distributions of the trajectories nor do we need to set any priors over latent variables. Zheng et al. [10] also predicted binned trajectories, but they used a recurrent convolutional neural network to predict the trajectory for a single player trajectory at a time at each time step.
+
+# 5.2 Transformers for multi-agent spatiotemporal modeling
+
+Giuliari et al. [31] used a Transformer to forecast the trajectories of individual pedestrians, i.e., the model does not consider interactions between individuals. Yu et al. [9] used separate temporal and spatial Transformers to forecast the trajectories of multiple, interacting pedestrians. Specifically, the temporal Transformer processes the coordinates of each pedestrian independently (i.e., it does not model interactions), while the spatial Transformer, which is inspired by Graph Attention Networks
+
+355 [8], processes the pedestrians independently at each time step. Sanford et al. [32] used a Transformer   
+356 to classify on-the-ball events from sequences in soccer games; however, only the coordinates of the   
+357 $K$ -nearest players to the ball were included in the input (along with the ball’s coordinates). Further,   
+358 the order of the included players was based on their average distance from the ball for a given   
+359 temporal window, which can lead to specific players changing position in the input between temporal   
+360 windows. As far as we are aware, baller2vec is the first Transformer capable of processing all   
+361 agents simultaneously across time without imposing an order on the agents.
+
+# 362 6 Limitations
+
+363 While baller2vec does not have a mechanism for handling unseen players, a number of different   
+364 solutions exist depending on the data available. For example, similar to what was proposed in Alcorn   
+365 [20], a model could be trained to map a vector of (e.g., NCAA) statistics and physical measurements   
+366 to baller2vec embeddings. Alternatively, if tracking data is available for the other league, a single   
+367 baller2vec model could be jointly trained on all the data.   
+368 At least two different factors may explain why including player identity as an input to baller2vec   
+369 only led to relatively small performance improvements. First, both player and ball trajectories are   
+370 fairly generic—players tend to move into open space, defenders tend to move towards their man or   
+371 the ball, point guards tend to pass to their teammates, and so on. Further, the location of a player   
+372 on the court is often indicative of their position, and players playing the same position tend to have   
+373 similar skills and physical attributes. As a result, we might expect baller2vec to be able to make   
+374 reasonable guesses about a player’s/ball’s trajectory just given the location of the players and the ball   
+375 on the court.   
+376 Second, baller2vec may be able to infer the identities of the players directly from the spatiotemporal   
+377 data. Unlike (batter|pitcher)2vec [20], which was trained on several seasons of Major League   
+378 Baseball data, baller2vec only had access to one half of one season’s worth of NBA data for   
+379 training. As a result, player identity may be entangled with season-specific factors (e.g., certain   
+380 rosters or coaches) that are actually exogenous to the player’s intrinsic qualities, i.e., baller2vec   
+381 may be overfitting to the season. To provide an example, the Golden State Warriors ran a very specific   
+382 kind of offense in the 2015-2016 season—breaking the previous record for most three-pointers made   
+383 in the regular season by $1 5 . 4 \%$ —and many basketball fans could probably recognize them from a   
+384 bird’s eye view (i.e., without access to any identifying information). Given additional seasons of data,   
+385 baller2vec would no longer be able to exploit the implicit identifying information contained in   
+386 static lineups and coaching strategies, so including player identity in the input would likely be more   
+387 beneficial in that case.
+
+# 388 7 Conclusion
+
+389 In this paper, we introduced baller2vec, a generalization of the standard Transformer that can   
+390 model sequential data consisting of multiple, unordered entities at each time step. As an architecture   
+391 that both is computationally efficient and has powerful representational capabilities, we believe   
+392 baller2vec represents an exciting new direction for MASM. As discussed in Section 6, training   
+393 baller2vec on more training data may allow the model to more accurately factor players away   
+394 from season-specific patterns. With additional data, more contextual information about agents (e.g.,   
+395 a player’s age, injury history, or minutes played in the game) and the game (e.g., the time left in   
+396 the period or the score difference) could be included as input, which might allow baller2vec to   
+397 learn an even more complete model of the game of basketball. Although we only experimented with   
+398 static, fully connected graphs here, baller2vec can easily be applied to more complex inputs—for   
+399 example, a sequence of graphs with changing nodes and edges—by adapting the self-attention mask   
+400 tensor as appropriate. Lastly, as a generative model (see Alcorn and Nguyen [33] for a full derivation),   
+401 baller2vec could be used for counterfactual simulations (e.g., assessing the impact of different   
+402 rosters), or combined with a controller to discover optimal play designs through reinforcement   
+403 learning.
+
+404 References [1] Panna Felsen, Patrick Lucey, and Sujoy Ganguly. Where will they go? predicting fine-grained adversarial multi-agent motion using conditional variational autoencoders. In Proceedings of the European Conference on Computer Vision (ECCV), pages 732–747, 2018. [2] Eric Zhan, Stephan Zheng, Yisong Yue, Long Sha, and Patrick Lucey. Generating multi-agent trajectories using programmatic weak supervision. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $\equiv$ rkxw-hAcFQ. [3] Raymond A Yeh, Alexander G Schwing, Jonathan Huang, and Kevin Murphy. Diverse generation for multi-agent sports games. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4610–4619, 2019. [4] Junyoung Chung, Kyle Kastner, Laurent Dinh, Kratarth Goel, Aaron Courville, and Yoshua Bengio. A recurrent latent variable model for sequential data. In Advances in Neural Information Processing Systems, 2015. [5] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pages 5998–6008, 2017. [6] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020. [7] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, and Neil Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id=YicbFdNTTy. [8] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. In International Conference on Learning Representations, 2018. [9] Cunjun Yu, Xiao Ma, Jiawei Ren, Haiyu Zhao, and Shuai Yi. Spatio-temporal graph transformer networks for pedestrian trajectory prediction. In Proceedings of the European Conference on Computer Vision (ECCV), August 2020. [10] Stephan Zheng, Yisong Yue, and Jennifer Hobbs. Generating long-term trajectories using deep hierarchical networks. Advances in Neural Information Processing Systems, 29:1543–1551, 2016. [11] Kazuki Irie, Albert Zeyer, Ralf Schlüter, and Hermann Ney. Language modeling with deep transformers. In Proc. Interspeech 2019, pages 3905–3909, 2019. doi: 10.21437/Interspeech. 2019-2225. URL http://dx.doi.org/10.21437/Interspeech.2019-2225.   
+440 [12] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2015. [13] Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. In Advances in Neural Information Processing Systems, 2016. [14] Kyunghyun Cho, Bart van Merriënboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using RNN encoder– decoder for statistical machine translation. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 1724–1734, Doha, Qatar, October 2014. Association for Computational Linguistics. doi: 10.3115/v1/D14-1179. URL https: //www.aclweb.org/anthology/D14-1179. [15] Basketball-Reference.com. 2015-16 nba player stats: Totals, February 2021. URL https: //www.basketball-reference.com/leagues/NBA_2016_totals.html.   
+52 [16] Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg Corrado, and Jeffrey Dean. Distributed representations of words and phrases and their compositionality. In Advances in Neural Information Processing Systems, 2013. [17] Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. arXiv preprint arXiv:1301.3781, 2013. [18] Quoc Le and Tomas Mikolov. Distributed representations of sentences and documents. In International conference on machine learning, pages 1188–1196. PMLR, 2014. [19] Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems, 2014. [20] Michael A Alcorn. (batter|pitcher)2vec: Statistic-free talent modeling with neural player embeddings. In MIT Sloan Sports Analytics Conference, 2018. [21] Leland McInnes, John Healy, and James Melville. Umap: Uniform manifold approximation and projection for dimension reduction. arXiv preprint arXiv:1802.03426, 2018.   
+65 [22] Alex Graves. Generating sequences with recurrent neural networks. arXiv preprint arXiv:1308.0850, 2013. [23] Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014.   
+69 [24] Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. In International Conference on Learning Representations, 2015. [25] Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In International Conference on Learning Representations, 2015. [26] Kihwan Kim, Matthias Grundmann, Ariel Shamir, Iain Matthews, Jessica Hodgins, and Irfan Essa. Motion fields to predict play evolution in dynamic sport scenes. In 2010 IEEE Computer Society Conference on Computer Vision and Pattern Recognition, pages 840–847. IEEE, 2010. [27] Hoang M Le, Yisong Yue, Peter Carr, and Patrick Lucey. Coordinated multi-agent imitation learning. In International Conference on Machine Learning, volume 70, pages 1995–2003, 2017. [28] Hoang M Le, Peter Carr, Yisong Yue, and Patrick Lucey. Data-driven ghosting using deep imitation learning. In MIT Sloan Sports Analytics Conference, 2017. [29] Mengshi Qi, Jie Qin, Yu Wu, and Yi Yang. Imitative non-autoregressive modeling for trajectory forecasting and imputation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 12736–12745, 2020. [30] Eric Zhan, Albert Tseng, Yisong Yue, Adith Swaminathan, and Matthew Hausknecht. Learning calibratable policies using programmatic style-consistency. In International Conference on Machine Learning, pages 11001–11011. PMLR, 2020. [31] Francesco Giuliari, Irtiza Hasan, Marco Cristani, and Fabio Galasso. Transformer networks for trajectory forecasting. In International Conference on Pattern Recognition, 2020. [32] Ryan Sanford, Siavash Gorji, Luiz G Hafemann, Bahareh Pourbabaee, and Mehrsan Javan. Group activity detection from trajectory and video data in soccer. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pages 898– 899, 2020.   
+93 [33] Michael A. Alcorn and Anh Nguyen. baller2vec $^ { + + }$ : A look-ahead multi-entity transformer for modeling coordinated agents. arXiv preprint arXiv:2104.11980, 2021.
+
+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] See Section 6.   
+(c) Did you discuss any potential negative societal impacts of your work? [No] Our work does not introduce new ethical challenges.   
+(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)? [N/A]   
+(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? [No] We link directly to the dataset.   
+(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]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/OsBM0sWwn_-/OsBM0sWwn_-_content_list.json

@@ -0,0 +1,1104 @@
+[
+    {
+        "type": "text",
+        "text": "baller2vec: A Multi-Entity Transformer For Multi-Agent Spatiotemporal Modeling ",
+        "text_level": 1,
+        "bbox": [
+            223,
+            122,
+            776,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            580,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Multi-agent spatiotemporal modeling is a challenging task from both an algorithmic   \n2 design and computational complexity perspective. Recent work has explored the   \n3 efficacy of traditional deep sequential models in this domain, but these architectures   \n4 are slow and cumbersome to train, particularly as model size increases. Further,   \n5 prior attempts to model interactions between agents across time have limitations,   \n6 such as imposing an order on the agents, or making assumptions about their relation  \n7 ships. In this paper, we introduce baller2vec1, a multi-entity generalization of   \n8 the standard Transformer that can, with minimal assumptions, simultaneously and   \n9 efficiently integrate information across entities and time. We test the effectiveness   \n10 of baller2vec for multi-agent spatiotemporal modeling by training it to perform   \n11 two different basketball-related tasks: (1) simultaneously modeling the trajectories   \n12 of all players on the court and (2) modeling the trajectory of the ball. Not only does   \n13 baller2vec learn to perform these tasks well (outperforming a graph recurrent   \n14 neural network with a similar number of parameters by a wide margin), it also   \n15 appears to “understand” the game of basketball, encoding idiosyncratic qualities of   \n16 players in its embeddings, and performing basketball-relevant functions with its   \n17 attention heads. ",
+        "bbox": [
+            148,
+            351,
+            766,
+            585
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "18 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            614,
+            312,
+            632
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "19 Whether it is a defender anticipating where the point guard will make a pass in a game of basketball,   \n20 a marketing professional guessing the next trending topic on a social media platform, or a theme   \n21 park manager forecasting the flow of visitor traffic, humans frequently attempt to predict phenomena   \n22 arising from processes involving multiple entities interacting through time. When designing learning   \n23 algorithms to perform such tasks, researchers face two main challenges: ",
+        "bbox": [
+            147,
+            648,
+            825,
+            717
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1. Given that entities lack a natural ordering, how do you effectively model interactions between entities across time?   \n2. How do you efficiently learn from the large, high-dimensional inputs inherent to such sequential data? ",
+        "bbox": [
+            196,
+            723,
+            825,
+            780
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Prior work in athlete trajectory modeling, a widely studied application of multi-agent spatiotemporal modeling (MASM; where entities are agents moving through space), has attempted to model player interactions through “role-alignment” preprocessing steps (i.e., imposing an order on the players) [1, 2] or graph neural networks [3], but these approaches may destroy identity information in the former case (see Section 4.2) or limit personalization in the latter case (see Section 5.1). Recently, researchers have experimented with variational recurrent neural networks (VRNNs) [4] to model ",
+        "bbox": [
+            168,
+            786,
+            825,
+            869
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "34 the temporal aspects of player trajectory data [3, 2], but the inherently sequential design of this   \n35 architecture limits the size of models that can feasibly be trained in experiments.   \n36 Transformers [5] were designed to circumvent the computational constraints imposed by other   \n37 sequential models, and they have achieved state-of-the-art results in a wide variety of sequence   \n38 learning tasks, both in natural language processing (NLP), e.g., GPT-3 [6], and computer vision, e.g.,   \n39 Vision Transformers [7]. While Transformers have successfully been applied to static multi-entity   \n40 data, e.g., graphs [8], the only published work we are aware of that attempts to model multi-entity   \n41 sequential data with Transformers uses four different Transformers to separately process information   \n42 temporally and spatially before merging the sub-Transformer outputs [9]. ",
+        "bbox": [
+            153,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            126,
+            825,
+            223
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/f9d9a840f11cf317947cc865472857e870a7cb57ba6e388aacea3ee8591c3f79.jpg",
+        "image_caption": [
+            "Figure 1: After solely being trained to model the trajectory of the ball ( ) given the locations of the players and the ball on the court through time, a self-attention (SA) head in baller2vec learned to anticipate passes. When the ball handler $( \\bullet \\circ )$ is driving towards the basket at $t \\ : = \\ : 4$ , SA assigns near-zero weights (black) to all players, suggesting no passes will be made. Indeed, the ball handler did not pass and dribbled into the lane $( t = 8 )$ ). SA then assigns a high weight (white) to a teammate $\\left( \\sqsupset \\right)$ , which correctly identifies the recipient of the pass at $t = 1 3$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            233,
+            532,
+            329
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduce a multientity Transformer that, with minimal assumptions, is capable of simultaneously integrating information across agents and time, which gives it powerful representational capabilities. We adapt the original Transformer architecture to suit multi-entity sequential data by converting the standard self-attention mask matrix used in NLP tasks into a novel self-attention mask tensor. To test the effectiveness of our multi-entity Transformer for MASM, we train it to perform two different basketball-related tasks (hence the name baller2vec): (1) simultaneously modeling the trajectories of all players on the court (Task P) and (2) modeling the trajectory of the ball ",
+        "bbox": [
+            578,
+            231,
+            825,
+            491
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(Task B). Further, we convert these tasks into classification problems by binning the Euclidean trajectory space, which allows baller2vec to learn complex, multimodal trajectory distributions via strictly maximizing the likelihood of the data (in contrast to variational approaches, which maximize the evidence lower bound and thus require priors over the latent variables). We find that: ",
+        "bbox": [
+            174,
+            491,
+            823,
+            546
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. baller2vec is an effective learning algorithm for MASM, obtaining a perplexity of 1.64 on Task P (compared to 15.72 when simply using the label distribution from the training set) and 13.44 on Task B (vs. 316.05) (Section 4.1). Further, compared to a graph recurrent neural network (GRNN) with similar capacity, baller2vec is ${ \\sim } 3 . 8$ times faster and achieves a $1 0 . 5 \\%$ lower average negative log-likelihood (NLL) on Task P (Section 4.1). ",
+        "bbox": [
+            212,
+            553,
+            823,
+            622
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2. baller2vec demonstrably integrates information across both agents and time to achieve these results, as evidenced by ablation experiments (Section 4.2). ",
+        "bbox": [
+            209,
+            622,
+            823,
+            650
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3. The identity embeddings learned by baller2vec capture idiosyncratic qualities of players, indicative of the model’s deep personalization capabilities (Section 4.3). ",
+        "bbox": [
+            204,
+            650,
+            823,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "4. baller2vec’s trajectory bin distributions depend on both the historical and current context (Section 4.4), and several attention heads appear to perform different basketball-relevant functions (Figure 1; Section 4.5), which suggests the model learned to “understand” the sport. ",
+        "bbox": [
+            212,
+            679,
+            825,
+            733
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Methods ",
+        "text_level": 1,
+        "bbox": [
+            158,
+            751,
+            277,
+            767
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Multi-entity sequences ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            781,
+            369,
+            796
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $A = \\{ 1 , 2 , \\dots , B \\}$ be a set indexing $B$ entities and $P = \\{ p _ { 1 } , p _ { 2 } , . . . , p _ { K } \\} \\subset A$ be the $K$ entities involved in a particular sequence. Further, let $Z _ { t } = \\{ z _ { t , 1 } , z _ { t , 2 } , \\dots , z _ { t , K } \\}$ be an unordered set of $K$ feature vectors such that $z _ { t , k }$ is the feature vector at time step $t$ for entity $p _ { k }$ . $\\mathcal { Z } = ( Z _ { 1 } , Z _ { 2 } , . . . , Z _ { T } )$ is thus an ordered sequence of sets of feature vectors over $T$ time steps. When $K = 1$ , $\\mathcal { Z }$ is a sequence of individual feature vectors, which is the underlying data structure for many NLP problems. ",
+        "bbox": [
+            168,
+            806,
+            823,
+            877
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "86 We now consider two different tasks: (1) sequential entity labeling, where each entity has its own label   \n87 at each time step (which is conceptually similar to word-level language modeling), and (2) sequential   \n88 labeling, where each time step has a single label (see Figure 3). For (1), let $\\mathcal { V } = ( V _ { 1 } , V _ { 2 } , \\ldots , V _ { T } )$ be   \n89 a sequence of sets of labels corresponding to $\\mathcal { Z }$ such that $V _ { t } = \\{ v _ { t , 1 } , v _ { t , 2 } , \\ldots , v _ { t , K } \\}$ and $v _ { t , k }$ is the   \n90 label at time step $t$ for the entity indexed by $k$ . For (2), let $W = ( w _ { 1 } , w _ { 2 } , \\dots , w _ { T } )$ be a sequence of   \n91 labels corresponding to $\\mathcal { Z }$ where $w _ { t }$ is the label at time step $t$ . The goal is then to learn a function $f$   \n92 that maps a set of entities and their time-dependent feature vectors $\\mathcal { Z }$ to a probability distribution   \n93 over either (1) the entities’ time-dependent labels $\\nu$ or (2) the sequence of labels $W$ . ",
+        "bbox": [
+            147,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            90,
+            825,
+            175
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "94 2.2 Multi-agent spatiotemporal modeling ",
+        "text_level": 1,
+        "bbox": [
+            156,
+            190,
+            473,
+            205
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "95 In the MASM setting, $P$ is a set of $K$ different agents and   \n96 $C _ { t } = \\{ ( x _ { t , 1 } , y _ { t , 1 } ) , ( \\bar { x } _ { t , 2 } , y _ { t , 2 } ) , \\ldots , ( x _ { t , K } , y _ { t , K } ) \\bar  \\}$ is an un  \n97 ordered set of $K$ coordinate pairs such that $( x _ { t , k } , y _ { t , k } )$ are   \n98 the coordinates for agent $p _ { k }$ at time step $t$ . The ordered   \n99 sequence of sets of coordinates $\\mathcal { C } = ( \\bar { C } _ { 1 } , C _ { 2 } , \\ldots , C _ { T } )$ ,   \n00 together with $P$ , thus defines the trajectories for the   \n101 $K$ agents over $T$ time steps. We then define $z _ { t , k }$ as:   \n102 $z _ { t , k } \\stackrel { - } { = } g ( [ e ( p _ { k } ) , x _ { t , k } , y _ { t , k } , \\stackrel { - } { h _ { t , k } } ] )$ , where $g$ is a multilayer   \n103 perceptron (MLP), $e$ is an agent embedding layer, and $h _ { t , k }$   \n104 is a vector of optional contextual features for agent $p _ { k }$ at   \n105 time step $t$ . The trajectory for agent $p _ { k }$ at time step $t$ is   \n106 defined as $( x _ { t + 1 , k } - x _ { t , k } , y _ { t + 1 , k } - y _ { t , k } )$ . Similar to Zheng   \n107 et al. [10], to fully capture the multimodal nature of the   \n08 trajectory distributions, we binned the 2D Euclidean space   \n109 into an $n \\times n$ grid (Figure 2) and treated the problem as a classification task. Therefore, $\\mathcal { Z }$ has a cor  \n110 responding sequence of sets of trajectory labels (i.e., $v _ { t , k } = \\mathrm { B i n } ( \\Delta x _ { t , k } , \\Delta y _ { t , k } )$ , so $v _ { t , k }$ is an integer   \n111 from one to $n ^ { 2 }$ ), and the loss for each sample in Task $\\mathbf { P }$ is: $\\begin{array} { r } { \\mathcal { L } = \\sum _ { t = 1 } ^ { T } \\sum _ { k = 1 } ^ { K } - \\ln ( f ( \\mathcal { Z } ) _ { t , k } [ v _ { t , k } ] ) } \\end{array}$   \n112 where $f ( \\mathcal { Z } ) _ { t , k } [ v _ { t , k } ]$ is the probability assigned to the trajectory label for agent $p _ { k }$ at time step $t$ by $f$ ;   \n113 i.e., the loss is the NLL of the data according to the model.   \n114 For Task $\\mathbf { B }$ , the loss for each sample is: $\\begin{array} { r } { \\mathcal { L } = \\sum _ { t = 1 } ^ { T } - \\ln ( f ( \\mathcal { Z } ) _ { t } [ w _ { t } ] ) } \\end{array}$ , where $f ( \\mathcal { Z } ) _ { t } [ \\boldsymbol { w } _ { t } ]$ is the   \n115 probability assigned to the trajectory label for the ball at time step $t$ by $f$ , and the labels correspond   \n116 to a binned 3D Euclidean space (i.e., $w _ { t } = \\mathrm { B i n } ( \\Delta x _ { t } , \\Delta y _ { t } , \\Delta z _ { t } )$ , so $w _ { t }$ is an integer from one to $n ^ { 3 }$ ).   \n118 We now describe our multi-entity   \n119 Transformer, baller2vec (Figure 3).   \n120 For NLP tasks, the Transformer self  \n121 attention mask $M$ takes the form of a   \n122 $T \\times T$ matrix (Figure 4) where $T$ is   \n123 the length of the sequence. The ele  \n124 ment at $M _ { t _ { 1 } , t _ { 2 } }$ thus indicates whether   \n125 or not the model can “look” at time   \n126 step $t _ { 2 }$ when processing time step   \n127 $t _ { 1 }$ . Here, we generalize the stan  \n128 dard Transformer to the multi-entity   \n129 setting by employing a $T \\times K \\times$   \n130 $T \\times K$ mask tensor where element   \n131 $M _ { t _ { 1 } , k _ { 1 } , t _ { 2 } , k _ { 2 } }$ indicates whether or not   \n132 the model can “look” at agent ${ { p } _ { k _ { 2 } } }$ at   \n133 time step $t _ { 2 }$ when processing agent   \n134 $p _ { k _ { 1 } }$ at time step $t _ { 1 }$ . Here, we mask   \n135 all elements where $t _ { 2 } > t _ { 1 }$ and leave   \n136 all remaining elements unmasked, i.e.,   \n137 baller2vec is a “causal” model.   \n138 In practice, to be compatible with Transformer implementations in major deep learning libraries,   \n139 we reshape $M$ into a $T K \\times T K$ matrix (Figure 4), and the input to the Transformer is a matrix   \n140 with shape $T K \\times F$ where $F$ is the dimension of each $z _ { t , k }$ . Irie et al. [11] observed that positional   \n141 encoding [5] is not only unnecessary, but detrimental for Transformers that use a causal attention   \n142 mask, so we do not use positional encoding with baller2vec. The remaining computations are   \n143 identical to the standard Transformer (see code). ",
+        "bbox": [
+            148,
+            215,
+            550,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/847eca0e9d29292771dadd98447cc88a9693ed7cbbe63daf4dc3437e54f8c767.jpg",
+        "image_caption": [
+            "Figure 2: An example of a binned trajectory. The agent’s starting position is at the center of the grid, and the cell containing the agent’s ending position is used as the label (of which there are $n ^ { 2 }$ possibilities). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            565,
+            188,
+            821,
+            308
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            410,
+            826,
+            482
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            488,
+            826,
+            534
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/d2c14159ab29fd5262ac92136e774591ebc66e2e94a3211eee68c647a9d42c6a.jpg",
+        "image_caption": [
+            "Figure 3: An overview of our multi-entity Transformer, baller2vec. Each time step $t$ consists of an unordered set $Z _ { t }$ of entity feature vectors (colored circles) as the input, with either (left) a corresponding set $V _ { t }$ of entity labels (colored diamonds) or (right) a single label $w _ { t }$ (gray triangle) as the target. Matching colored circles/diamonds across time steps correspond to the same entity. In our experiments, each entity feature vector $z _ { t , k }$ is produced by an MLP $g$ that takes a player’s identity embedding $e ( p _ { k } )$ , raw court coordinates $( x _ { t , k } , y _ { t , k } )$ , and a binary variable indicating the player’s frontcourt $h _ { t , k }$ as input. Each entity label $v _ { t , k }$ is an integer indexing the trajectory bin derived from the player’s raw trajectory, while each $w _ { t }$ is an integer indexing the ball’s trajectory bin. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            546,
+            821,
+            742
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            90,
+            419,
+            366
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/298f2bcb2493ccbe12780271785c406d40208b6be2c23a9fde161e8519c7f386.jpg",
+        "image_caption": [
+            "Figure 4: Left: the standard self-attention mask matrix $M$ . The element at $M _ { t _ { 1 } , t _ { 2 } }$ indicates whether or not the model can “look” at time step $t _ { 2 }$ when processing time step $t _ { 1 }$ . Right: the matrix form of our multi-entity self-attention mask tensor. In tensor form, element $M _ { t _ { 1 } , k _ { 1 } , t _ { 2 } , k _ { 2 } }$ indicates whether or not the model can “look” at agent $p _ { k _ { 2 } }$ at time step $t _ { 2 }$ when processing agent $p _ { k _ { 1 } }$ at time step $t _ { 1 }$ . In matrix form, this corresponds to element $M _ { t _ { 1 } K + k _ { 1 } , t _ { 2 } K + k _ { 2 } }$ when using zerobased indexing. The $M$ shown here is for a static, fully connected graph, but other, potentially evolving network structures can be encoded in the attention mask tensor. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            454,
+            80,
+            802,
+            205
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            373,
+            825,
+            457
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            476,
+            312,
+            493
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Dataset ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            507,
+            266,
+            522
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We trained baller2vec on a publicly available dataset of player and ball trajectories recorded from 631 National Basketball Association (NBA) games from the 2015-2016 season.2 All 30 NBA teams and 450 different players were represented. Because transition sequences are a strategically important part of basketball, unlike prior work, e.g., Felsen et al. [1], Yeh et al. [3], Zhan et al. [2], we did not terminate sequences on a change of possession, nor did we constrain ourselves to a fixed subset of sequences. Instead, each training sample was generated on the fly by first randomly sampling a game, and then randomly sampling a starting time from that game. The following four seconds of data were downsampled to $5 \\mathrm { H z }$ from the original $2 5 \\ : \\mathrm { H z }$ and used as the input. ",
+        "bbox": [
+            173,
+            532,
+            825,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Because we did not terminate sequences on a change of possession, we could not normalize the direction of the court as was done in prior work [1, 3, 2]. Instead, for each sampled sequence, 56 we randomly (with a probability of 0.5) rotated the court $1 8 0 ^ { \\circ }$ (because the court’s direction is arbitrary), doubling the size of the dataset. We used a training/validation/test split of 569/30/32 58 games, respectively (i.e., $5 \\%$ of the games were used for testing, and $5 \\%$ of the remaining $9 5 \\%$ 59 of games were used for validation). As a result, we had access to ${ \\sim } 8 2$ million different (albeit 0 overlapping) training sequences (569 games $\\times 4$ periods per game $\\times \\ 1 2$ minutes per period $\\times 6 0$ seconds per minute $\\times 2 5 \\mathrm { H z } \\times 2$ rotations), ${ \\sim } 8 0 0 \\mathrm { x }$ the number of sequences used in prior work. 2 For both the validation and test sets, $\\mathord { \\sim } 1 , 0 0 0$ different, non-overlapping sequences were selected for 3 evaluation by dividing each game into $\\lceil \\frac { 1 , 0 0 0 } { N } \\rceil$ non-overlapping chunks (where $N$ is the number of games), and using the starting four seconds from each chunk as the evaluation sequence. ",
+        "bbox": [
+            155,
+            650,
+            825,
+            804
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Model ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            820,
+            258,
+            834
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We trained separate models for Task $\\mathbf { P }$ and Task B. For all experiments, we used a single Transformer architecture that was nearly identical to the original model described in Vaswani et al. [5], with $d _ { \\mathrm { m o d e l } } = 5 1 2$ (the dimension of the input and output of each Transformer layer), eight attention heads, ",
+        "bbox": [
+            176,
+            845,
+            825,
+            887
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "169 $d _ { \\mathrm { f f } } = 2 0 4 8$ (the dimension of the inner feedforward layers), and six layers, although we did not use   \n170 dropout. For both Task $\\mathbf { P }$ and Task $\\mathbf { B }$ , the players and the ball were included in the input, and both   \n171 the players and the ball were embedded to 20-dimensional vectors. The input features for each player   \n172 consisted of his identity, his $( x , y )$ coordinates on the court at each time step in the sequence, and a   \n173 binary variable indicating the side of his frontcourt (i.e., the direction of his team’s hoop).3 The input   \n174 features for the ball were its $( x , y , z )$ coordinates at each time step.   \n175 The input features for the players and the ball were processed by separate, three-layer MLPs before   \n176 being fed into the Transformer. Each MLP had 128, 256, and 512 nodes in its three layers, respectively,   \n177 and a ReLU nonlinearity following each of the first two layers. For classification, a single linear layer   \n178 was applied to the Transformer output followed by a softmax. For players, we binned an $1 1 \\mathrm { f t } \\times 1 1$ ft   \n179 2D Euclidean trajectory space into an $1 1 \\times 1 1$ grid of $1 \\mathrm { f t } \\times 1$ ft squares for a total of 121 player   \n180 trajectory labels. Similarly, for the ball, we binned a $1 9 \\ : \\mathrm { f t } \\times 1 9$ ft $\\times 1 9$ ft 3D Euclidean trajectory   \n181 space into a $1 9 \\times 1 9 \\times 1 9$ grid of $1 \\mathrm { f t } \\times 1$ ft $\\times 1$ ft cubes for a total of 6,859 ball trajectory labels.   \n182 We used the Adam optimizer [12] with an initial learning rate of $1 0 ^ { - 6 }$ , $\\beta _ { 1 } = 0 . 9$ , $\\beta _ { 2 } = 0 . 9 9 9$ , and   \n183 $\\epsilon = 1 0 ^ { - 9 }$ to update the model’s parameters, of which there were ${ \\sim } 1 9 / 2 3$ million for Task P/Task B,   \n184 respectively. The learning rate was reduced to $1 0 ^ { - 7 }$ after 20 consecutive epochs of the validation loss   \n185 not improving. Models were implemented in PyTorch and trained on a single NVIDIA GTX $1 0 8 0 \\mathrm { T i }$   \n186 GPU for seven days $\\mathord { \\sim } 6 5 0$ epochs) where each epoch consisted of 20,000 training samples, and the   \n187 validation set was used for early stopping. ",
+        "bbox": [
+            140,
+            92,
+            825,
+            175
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            181,
+            825,
+            279
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            284,
+            825,
+            368
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Baselines ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            383,
+            276,
+            397
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "89 As our naive baseline, we used the marginal distribution of   \n90 the trajectory bins from the training set for all predictions.   \n91 For our strong baseline, we implemented a baller2vec  \n92 like graph recurrent neural network (GRNN) and trained   \n93 it on Task P (code is available in the baller2vec repos  \n94 itory).4 Specifically, at each time step, the player and ball   \n95 inputs were first processed using MLPs as in baller2vec,   \n96 and these inputs were then fed into a graph neural net  \n97 work (GNN) similar to Yeh et al. [3]. The node and   \n98 edge functions of the GNN were each a Transformer  \n99 like feedforward network (TFF), i.e., $\\mathrm { T F F } ( x ) = \\mathrm { L N } ( x +$   \n00 $W _ { 2 } \\mathrm { R e L U } ( W _ { 1 } x + b _ { 1 } ) + b _ { 2 } )$ , where LN is Layer Normal  \n01 ization [13], $W _ { 1 }$ and $W _ { 2 }$ are weight matrices, $b _ { 1 }$ and $b _ { 2 }$ ",
+        "bbox": [
+            150,
+            409,
+            550,
+            588
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1: The perplexity per trajectory bin on the test set when using baller2vec vs. the marginal distribution of the trajectory bins in the training set (“Train”) for all predictions. baller2vec considerably reduces the uncertainty over the trajectory bins. ",
+        "bbox": [
+            562,
+            410,
+            825,
+            506
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/9a57a483186fafb605621468d7e24262a876e11711f9d5a7a0deb43192375e62.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">baller2vec</td><td>Train</td></tr><tr><td>Task P</td><td>1.64</td><td>15.72</td></tr><tr><td>Task B</td><td>13.44</td><td>316.05</td></tr></table>",
+        "bbox": [
+            570,
+            512,
+            810,
+            570
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "02 are bias vectors, and ReLU is the rectifier activation function. For our RNN, we used a gated recurrent   \n203 unit (GRU) RNN [14] in which we replaced each of the six weight matrices of the GRU with a TFF.   \n04 Each TFF had the same dimensions as the Transformer layers used in baller2vec. Our GRNN had   \n205 ${ \\sim } 1 8 \\mathbf { M }$ parameters, which is comparable to the ${ \\sim } 1 9 \\mathbf { M }$ in baller2vec. We also trained our GRNN   \n206 for seven days ${ \\sim } 1 7 5$ epochs). ",
+        "bbox": [
+            150,
+            588,
+            825,
+            657
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 Ablation studies ",
+        "text_level": 1,
+        "bbox": [
+            158,
+            674,
+            326,
+            688
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To assess the impacts of the multi-entity design and player embeddings of baller2vec on model performance, we trained three variations of our Task $\\mathbf { P }$ model using: (1) one player in the input without player identity, (2) all 10 players in the input without player identity, and (3) all 10 players in the input with player identity. In experiments where player identity was not used, a single generic player embedding was used in place of the player identity embeddings. We also trained two variations of our Task B model: one with player identity and one without. Lastly, to determine the extent to which baller2vec uses historical information in its predictions, we compared the performance of our best Task P model on the full sequence test set with its performance on the test set when only predicting the trajectories for the first frame (i.e., we applied the same model to only the first frames of the test set). ",
+        "bbox": [
+            173,
+            699,
+            825,
+            837
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 baller2vec is an effective learning algorithm for multi-agent spatiotemporal modeling. ",
+        "text_level": 1,
+        "bbox": [
+            163,
+            122,
+            818,
+            137
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The average NLL on the test set for our best Task $\\mathbf { P }$ model was 0.492, while the average NLL for our best Task B model was 2.598. In NLP, model performance is often expressed in terms of the perplexity per word, which, intuitively, is the number of faces on a fair die that has the same amount of uncertainty as the model per word (i.e., a uniform distribution over $M$ labels has a perplexity of $M$ , so a model with a per word perplexity of six has the same average uncertainty as rolling a fair six-sided die). In our case, we con",
+        "bbox": [
+            174,
+            148,
+            413,
+            354
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2: The average NLL (lower is better) on the Task $\\mathbf { P }$ test set and seconds per training epoch (SPE) for baller2vec (b2v) and our GRNN. baller2vec trains ${ \\sim } 3 . 8$ times faster per epoch compared to our GRNN, and baller2vec outperformed our GRNN by $1 0 . 5 \\%$ when given the same amount of training time. Even when only allowed to train for half $( ^ { 6 6 } 0 . 5 \\mathrm { x } ^ { 7 } )$ and a quarter $( ^ { 6 4 } 0 . 2 5 \\mathrm { x } ^ { 3 7 } )$ as long as our GRNN, baller2vec outperformed our GRNN by $9 . 1 \\%$ and $1 . 5 \\%$ , respectively.. ",
+        "bbox": [
+            426,
+            154,
+            825,
+            280
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/f4f073888e50e4934038d6229e85770df2f482678f9bbe34d79b05ec21828185.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>b2v</td><td>b2v (0.5x)</td><td>b2v (0.25x)</td><td>GRNN</td></tr><tr><td>NLL</td><td>0.492</td><td>0.499</td><td>0.541</td><td>0.549</td></tr><tr><td>SPE</td><td>~900</td><td>~900</td><td>~900</td><td>~3,400</td></tr></table>",
+        "bbox": [
+            441,
+            285,
+            808,
+            343
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "sider the perplexity per trajectory bin, defined as: $\\begin{array} { r } { P P = e ^ { \\frac { 1 } { N T K } } \\sum _ { n = 1 } ^ { N } \\sum _ { t = 1 } ^ { T } \\sum _ { k = 1 } ^ { K } - \\ln ( p ( v _ { n , t , k } ) ) } \\end{array}$ , where $N$ is the number of sequences. Our best Task $\\mathbf { P }$ model achieved a $P P$ of 1.64, i.e., baller2vec was, on average, as uncertain as rolling a 1.64-sided fair die (better than a coin flip) when predicting player trajectory bins (Table 1). For comparison, when using the distribution of the player trajectory bins in the training set as the predicted probabilities, the $P P$ on the test set was 15.72. Our best Task B model achieved a $P P$ of 13.44 (compared to 316.05 when using the training set distribution). ",
+        "bbox": [
+            174,
+            354,
+            825,
+            440
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Compared to our GRNN, baller2vec was ${ \\sim } 3 . 8$ times faster and had a $1 0 . 5 \\%$ lower average NLL when given an equal amount of training time (Table 2). Even when only given half as much training time as our GRNN, baller2vec had a $9 . 1 \\%$ lower average NLL. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            489
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 baller2vec uses information about all players on the court through time, in addition to player identity, to model spatiotemporal dynamics. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            507,
+            820,
+            536
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results for our ablation experiments can be seen in Table 3. Including all 10 players in the input dramatically improved the performance of our Task P model by $1 8 . 0 \\%$ vs. only including a single player. Including player identity improved the model’s performance a further $4 . 4 \\%$ . This stands in contrast to Felsen et al. [1] where the inclusion of player identity led to slightly worse model performance; a counterintuitive result given the range of skills among NBA players, but possibly a side effect of their rolealignment procedure. Additionally, when replacing the players in each test set sequence with random players, the performance of our best Task P model deteriorated by $6 . 2 \\%$ from 0.492 to 0.522. Interestingly, including player identity only improved our Task B model’s performance by $2 . 7 \\%$ . Lastly, our best Task $\\mathbf { P }$ model’s performance on the full sequence test set ",
+        "bbox": [
+            174,
+            547,
+            517,
+            781
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 3: The average NLL on the test set for each of the models in our ablation experiments (lower is better). For Task P, using all 10 players improved model performance by $1 8 . 0 \\%$ , while using player identity improved model performance by an additional $4 . 4 \\%$ . For Task B, using player identity improved model performance by $2 . 7 \\%$ . 1/10 indicates whether one or 10 players were used as input, respectively, while I/NI indicates whether or not player identity was used, respectively. ",
+        "bbox": [
+            529,
+            554,
+            825,
+            707
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/6e81b9ad56cf4e96d72426878a1bb86072707823976c415b25c73b0730e9f281.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>1-NI 10-NI</td><td>10-1</td></tr><tr><td>Task P</td><td>0.628 0.515</td><td>0.492</td></tr><tr><td>Task B</td><td>N/A 2.670</td><td>2.598</td></tr></table>",
+        "bbox": [
+            552,
+            712,
+            795,
+            770
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(0.492) was $7 0 . 6 \\%$ better than its performance on the single frame test set (1.67), i.e., baller2vec is clearly using historical information to model the spatiotemporal dynamics of basketball. ",
+        "bbox": [
+            166,
+            782,
+            825,
+            810
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "65 4.3 baller2vec’s learned player embeddings encode individual attributes. ",
+        "text_level": 1,
+        "bbox": [
+            156,
+            829,
+            705,
+            844
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Neural language models are widely known for their ability to encode semantic relationships between words and phrases as geometric relationships between embeddings—see, e.g., Mikolov et al. [16, 17], Le and Mikolov [18], Sutskever et al. [19]. Alcorn [20] observed a similar phenomenon in a baseball setting, where batters and pitchers with similar skills were found next to each other in the ",
+        "bbox": [
+            173,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/78a776bc2ff86bfe2bdfde6df160c8840f679871731d048ca55fb87d9ebbcab9.jpg",
+        "image_caption": [
+            "Figure 5: As can be seen in this 2D UMAP of the player embeddings, by exclusively learning to predict the trajectory of the ball, baller2vec was able to infer idiosyncratic player attributes. The left-hand side of the plot contains tall post players $( \\neg , \\sqsupset )$ , e.g., Serge Ibaka, while the right-hand side of the plot contains shorter shooting guards $( \\frac { \\lambda } { 2 5 } )$ and point guards $( + )$ , e.g., Stephen Curry. The connecting transition region contains forwards $( \\sqsubseteq , \\bigcirc )$ and other “hybrid” players, i.e., individuals possessing both guard and post skills, e.g., LeBron James. Further, players with similar defensive abilities, measured here by the cube root of the players’ blocks per minute in the 2015-2016 season [15], cluster together. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            88,
+            820,
+            262
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "270 embedding space learned by a neural network trained to predict the outcome of an at-bat. A 2D   \n271 UMAP [21] of the player embeddings learned by baller2vec for Task B can be seen in Figure 5.   \n272 Like (batter|pitcher)2vec [20], baller2vec seems to encode skills and physical attributes in   \n273 its player embeddings. ",
+        "bbox": [
+            138,
+            417,
+            825,
+            473
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Querying the nearest neighbors for individual players reveals further insights about the baller2vec embeddings. For example, the nearest neighbor for Russell Westbrook, an extremely athletic $6 3 \"$ point guard, is Derrick Rose, a $6 2 \"$ point guard also known for his athleticism. Amusingly, the nearest neighbor for Pau Gasol, a 7’1\" center with a respectable shooting range, is his younger brother Marc Gasol, a $6 7 1 1 \"$ center, also with a respectable shooting range. ",
+        "bbox": [
+            514,
+            479,
+            823,
+            631
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/d9f498eb7c6fa700f87e0a7514776c4598e51d13690973e09e4f71aabc938d2d.jpg",
+        "image_caption": [
+            "Figure 6: baller2vec’s trajectory predicted trajectory bin distributions are affected by both the historical and current context. At $t ~ = ~ 1$ , baller2vec is fairly uncertain about the target player’s ( ; $k = 8$ ) trajectory (left grid and dotted red line; the blue-bordered center cell is the “stationary” trajectory), with most of the probability mass divided between trajectories moving towards the ball handler’s sideline (right grid; black $= 1 . 0$ ; white $= 0 . 0$ ). After observing a portion of the sequence $\\mathit { t } = 6 $ ), baller2vec becomes very certain about the target player’s trajectory $( f _ { 6 , 8 } )$ , but when the player reaches a decision point $\\mathit { t } = 1 3$ ), baller2vec becomes split between trajectories (staying still or moving towards the top of the key). Additional examples can be found in Figure S1. $\\mathrm { { O } = \\ b a l l }$ , $\\sqsubset =$ offense, $\\Delta =$ defense, and $f _ { t , k } = f ( \\mathcal { Z } ) _ { t , k }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            165,
+            484,
+            500,
+            628
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 baller2vec’s predicted trajectory bin distributions depend on both the historical and current context. ",
+        "text_level": 1,
+        "bbox": [
+            514,
+            651,
+            808,
+            691
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Because baller2vec explicitly models the distribution of the player trajectories (unlike variational methods), we can easily visualize how its predicted trajectory bin distributions shift in different situations. As can be seen in Figure 6, baller2vec’s predicted trajectory bin distributions depend on both the historical and current context. When provided with limited historical information, baller2vec tends to be less certain about where the players might go. baller2vec also tends to be more certain when predicting trajectory bins at “easy” moments (e.g., a player moving into open space) vs. “hard” moments (e.g., an offensive player choosing which direction to move around a defender). ",
+        "bbox": [
+            514,
+            705,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "One intriguing property of the attention mechanism [22–25] is how, when visualized, the attention weights often seem to reveal how a model is “thinking”. For example, Vaswani et al. [5] discovered examples of attention heads in their Transformer that appear to be performing various language understanding subtasks, such as anaphora resolution. As can be seen in Figure 7, some of the attention heads in baller2vec seem to be performing basketball understanding subtasks, such as keeping track of the ball handler’s teammates, and anticipating who the ball handler will pass to, which, intuitively, help with our task of predicting the ball’s trajectory. ",
+        "bbox": [
+            173,
+            117,
+            485,
+            309
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            329,
+            321,
+            344
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 Trajectory modeling in sports ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            359,
+            419,
+            373
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "There is a rich literature on MASM, particularly in the context of sports, e.g., Kim et al. [26], Zheng et al. [10], Le et al. [27, 28], Qi et al. [29], Zhan et al. [30]. Most relevant to our work is Yeh et al. [3], who used a variational recurrent neural network combined with a graph neural ",
+        "bbox": [
+            174,
+            385,
+            485,
+            467
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/71634d4f5d6c0f7b7fb066cfa62f54482eded9f138e6750c33eb669a9bb6d4ba.jpg",
+        "image_caption": [
+            "Figure 7: The attention outputs from baller2vec suggest it learned basketball-relevant functions. Left: attention head 2-7 (layer-head) appears to focus on teammates of the ball handler $( \\infty )$ . Middle and right: attention head 6-2 seems to predict (middle; ) who the ball handler will be in a future frame (right). Players are shaded according to the sum of the attention weights assigned to the players through time with reference to the ball in the current frame (recall that each player occurs multiple times in the input). Higher attention weights are lighter. For both of these attention heads, the sum of the attention weights assigned to the ball through time was small (0.01 for both the left and middle frames where the maximum is 1.00). Additional examples can be found in Figures S2 and S3. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            114,
+            823,
+            202
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "network to forecast trajectories in a multi-agent setting. Like their approach, our model is permutation equivariant with regard to the ordering of the agents; however, we use a multi-head attention mechanism to achieve this permutation equivariance while the permutation equivariance in Yeh et al. [3] is provided by the graph neural network. Specifically, Yeh et al. [3] define: $v  e : { \\bf e } _ { i , j } =$ $f _ { e } \\big ( \\big [ \\mathbf { v } _ { i } , \\mathbf { v } _ { j } , \\mathbf { t } _ { i , j } \\big ] \\big )$ and $\\begin{array} { r } { e  \\bar { v ^ { } } : { \\mathbf { 0 } } _ { i } = f _ { v } ( \\sum _ { j \\in \\mathcal { N } _ { i } } [ \\mathbf { e } _ { i , j } , \\mathbf { t } _ { i } ] ) } \\end{array}$ , where ${ \\bf v } _ { i }$ is the initial state of agent $i$ , $\\mathbf { t } _ { i , j }$ is an embedding for the edge between agents $i$ and $j$ , $\\mathbf { e } _ { i , j }$ is the representation for edge $( i , j )$ , ${ \\mathcal { N } } _ { i }$ is the neighborhood for agent $i$ , $\\mathbf { t } _ { i }$ is a node embedding for agent $i$ , $\\mathbf { o } _ { i }$ is the output state for agent $i$ , and $f _ { e }$ and $f _ { v }$ are deep neural networks. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            580
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Assuming each individual player is a different “type” in $f _ { e }$ (i.e., attempting to maximize the level of personalization) would require $4 5 0 ^ { 2 } = 2 0 2 { , } 5 0 0$ (i.e., $B ^ { 2 }$ ) different $t _ { i , j }$ edge embeddings, many of which would never be used during training and thus inevitably lead to poor out-of-sample performance. Reducing the number of type embeddings requires making assumptions about the nature of the relationships between nodes. By using a multi-head attention mechanism, baller2vec learns to integrate information about different agents in a highly flexible manner that is both agent and timedependent, and can generalize to unseen agent combinations. The attention heads in baller2vec are somewhat analogous to edge types, but, importantly, they do not require a priori knowledge about the relationships between the players. ",
+        "bbox": [
+            163,
+            585,
+            825,
+            712
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Additionally, unlike recent works that use variational methods to train their generative models [3, 1, 2], we translate the multi-agent trajectory modeling problem into a classification task, which allows us to train our model by strictly maximizing the likelihood of the data. As a result, we do not make any assumptions about the distributions of the trajectories nor do we need to set any priors over latent variables. Zheng et al. [10] also predicted binned trajectories, but they used a recurrent convolutional neural network to predict the trajectory for a single player trajectory at a time at each time step. ",
+        "bbox": [
+            169,
+            718,
+            825,
+            801
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 Transformers for multi-agent spatiotemporal modeling ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            816,
+            594,
+            830
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Giuliari et al. [31] used a Transformer to forecast the trajectories of individual pedestrians, i.e., the model does not consider interactions between individuals. Yu et al. [9] used separate temporal and spatial Transformers to forecast the trajectories of multiple, interacting pedestrians. Specifically, the temporal Transformer processes the coordinates of each pedestrian independently (i.e., it does not model interactions), while the spatial Transformer, which is inspired by Graph Attention Networks ",
+        "bbox": [
+            173,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "355 [8], processes the pedestrians independently at each time step. Sanford et al. [32] used a Transformer   \n356 to classify on-the-ball events from sequences in soccer games; however, only the coordinates of the   \n357 $K$ -nearest players to the ball were included in the input (along with the ball’s coordinates). Further,   \n358 the order of the included players was based on their average distance from the ball for a given   \n359 temporal window, which can lead to specific players changing position in the input between temporal   \n360 windows. As far as we are aware, baller2vec is the first Transformer capable of processing all   \n361 agents simultaneously across time without imposing an order on the agents. ",
+        "bbox": [
+            140,
+            92,
+            825,
+            189
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "362 6 Limitations ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            224,
+            302,
+            242
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "363 While baller2vec does not have a mechanism for handling unseen players, a number of different   \n364 solutions exist depending on the data available. For example, similar to what was proposed in Alcorn   \n365 [20], a model could be trained to map a vector of (e.g., NCAA) statistics and physical measurements   \n366 to baller2vec embeddings. Alternatively, if tracking data is available for the other league, a single   \n367 baller2vec model could be jointly trained on all the data.   \n368 At least two different factors may explain why including player identity as an input to baller2vec   \n369 only led to relatively small performance improvements. First, both player and ball trajectories are   \n370 fairly generic—players tend to move into open space, defenders tend to move towards their man or   \n371 the ball, point guards tend to pass to their teammates, and so on. Further, the location of a player   \n372 on the court is often indicative of their position, and players playing the same position tend to have   \n373 similar skills and physical attributes. As a result, we might expect baller2vec to be able to make   \n374 reasonable guesses about a player’s/ball’s trajectory just given the location of the players and the ball   \n375 on the court.   \n376 Second, baller2vec may be able to infer the identities of the players directly from the spatiotemporal   \n377 data. Unlike (batter|pitcher)2vec [20], which was trained on several seasons of Major League   \n378 Baseball data, baller2vec only had access to one half of one season’s worth of NBA data for   \n379 training. As a result, player identity may be entangled with season-specific factors (e.g., certain   \n380 rosters or coaches) that are actually exogenous to the player’s intrinsic qualities, i.e., baller2vec   \n381 may be overfitting to the season. To provide an example, the Golden State Warriors ran a very specific   \n382 kind of offense in the 2015-2016 season—breaking the previous record for most three-pointers made   \n383 in the regular season by $1 5 . 4 \\%$ —and many basketball fans could probably recognize them from a   \n384 bird’s eye view (i.e., without access to any identifying information). Given additional seasons of data,   \n385 baller2vec would no longer be able to exploit the implicit identifying information contained in   \n386 static lineups and coaching strategies, so including player identity in the input would likely be more   \n387 beneficial in that case. ",
+        "bbox": [
+            145,
+            267,
+            825,
+            337
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            343,
+            825,
+            453
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            459,
+            825,
+            626
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "388 7 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            662,
+            299,
+            679
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "389 In this paper, we introduced baller2vec, a generalization of the standard Transformer that can   \n390 model sequential data consisting of multiple, unordered entities at each time step. As an architecture   \n391 that both is computationally efficient and has powerful representational capabilities, we believe   \n392 baller2vec represents an exciting new direction for MASM. As discussed in Section 6, training   \n393 baller2vec on more training data may allow the model to more accurately factor players away   \n394 from season-specific patterns. With additional data, more contextual information about agents (e.g.,   \n395 a player’s age, injury history, or minutes played in the game) and the game (e.g., the time left in   \n396 the period or the score difference) could be included as input, which might allow baller2vec to   \n397 learn an even more complete model of the game of basketball. Although we only experimented with   \n398 static, fully connected graphs here, baller2vec can easily be applied to more complex inputs—for   \n399 example, a sequence of graphs with changing nodes and edges—by adapting the self-attention mask   \n400 tensor as appropriate. Lastly, as a generative model (see Alcorn and Nguyen [33] for a full derivation),   \n401 baller2vec could be used for counterfactual simulations (e.g., assessing the impact of different   \n402 rosters), or combined with a controller to discover optimal play designs through reinforcement   \n403 learning. ",
+        "bbox": [
+            140,
+            704,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "404 References [1] Panna Felsen, Patrick Lucey, and Sujoy Ganguly. Where will they go? predicting fine-grained adversarial multi-agent motion using conditional variational autoencoders. In Proceedings of the European Conference on Computer Vision (ECCV), pages 732–747, 2018. [2] Eric Zhan, Stephan Zheng, Yisong Yue, Long Sha, and Patrick Lucey. Generating multi-agent trajectories using programmatic weak supervision. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $\\equiv$ rkxw-hAcFQ. [3] Raymond A Yeh, Alexander G Schwing, Jonathan Huang, and Kevin Murphy. Diverse generation for multi-agent sports games. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4610–4619, 2019. [4] Junyoung Chung, Kyle Kastner, Laurent Dinh, Kratarth Goel, Aaron Courville, and Yoshua Bengio. A recurrent latent variable model for sequential data. In Advances in Neural Information Processing Systems, 2015. [5] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pages 5998–6008, 2017. [6] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020. [7] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, and Neil Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id=YicbFdNTTy. [8] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. In International Conference on Learning Representations, 2018. [9] Cunjun Yu, Xiao Ma, Jiawei Ren, Haiyu Zhao, and Shuai Yi. Spatio-temporal graph transformer networks for pedestrian trajectory prediction. In Proceedings of the European Conference on Computer Vision (ECCV), August 2020. [10] Stephan Zheng, Yisong Yue, and Jennifer Hobbs. Generating long-term trajectories using deep hierarchical networks. Advances in Neural Information Processing Systems, 29:1543–1551, 2016. [11] Kazuki Irie, Albert Zeyer, Ralf Schlüter, and Hermann Ney. Language modeling with deep transformers. In Proc. Interspeech 2019, pages 3905–3909, 2019. doi: 10.21437/Interspeech. 2019-2225. URL http://dx.doi.org/10.21437/Interspeech.2019-2225.   \n440 [12] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2015. [13] Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. In Advances in Neural Information Processing Systems, 2016. [14] Kyunghyun Cho, Bart van Merriënboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using RNN encoder– decoder for statistical machine translation. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 1724–1734, Doha, Qatar, October 2014. Association for Computational Linguistics. doi: 10.3115/v1/D14-1179. URL https: //www.aclweb.org/anthology/D14-1179. [15] Basketball-Reference.com. 2015-16 nba player stats: Totals, February 2021. URL https: //www.basketball-reference.com/leagues/NBA_2016_totals.html.   \n52 [16] Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg Corrado, and Jeffrey Dean. Distributed representations of words and phrases and their compositionality. In Advances in Neural Information Processing Systems, 2013. [17] Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. arXiv preprint arXiv:1301.3781, 2013. [18] Quoc Le and Tomas Mikolov. Distributed representations of sentences and documents. In International conference on machine learning, pages 1188–1196. PMLR, 2014. [19] Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems, 2014. [20] Michael A Alcorn. (batter|pitcher)2vec: Statistic-free talent modeling with neural player embeddings. In MIT Sloan Sports Analytics Conference, 2018. [21] Leland McInnes, John Healy, and James Melville. Umap: Uniform manifold approximation and projection for dimension reduction. arXiv preprint arXiv:1802.03426, 2018.   \n65 [22] Alex Graves. Generating sequences with recurrent neural networks. arXiv preprint arXiv:1308.0850, 2013. [23] Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014.   \n69 [24] Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. In International Conference on Learning Representations, 2015. [25] Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In International Conference on Learning Representations, 2015. [26] Kihwan Kim, Matthias Grundmann, Ariel Shamir, Iain Matthews, Jessica Hodgins, and Irfan Essa. Motion fields to predict play evolution in dynamic sport scenes. In 2010 IEEE Computer Society Conference on Computer Vision and Pattern Recognition, pages 840–847. IEEE, 2010. [27] Hoang M Le, Yisong Yue, Peter Carr, and Patrick Lucey. Coordinated multi-agent imitation learning. In International Conference on Machine Learning, volume 70, pages 1995–2003, 2017. [28] Hoang M Le, Peter Carr, Yisong Yue, and Patrick Lucey. Data-driven ghosting using deep imitation learning. In MIT Sloan Sports Analytics Conference, 2017. [29] Mengshi Qi, Jie Qin, Yu Wu, and Yi Yang. Imitative non-autoregressive modeling for trajectory forecasting and imputation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 12736–12745, 2020. [30] Eric Zhan, Albert Tseng, Yisong Yue, Adith Swaminathan, and Matthew Hausknecht. Learning calibratable policies using programmatic style-consistency. In International Conference on Machine Learning, pages 11001–11011. PMLR, 2020. [31] Francesco Giuliari, Irtiza Hasan, Marco Cristani, and Fabio Galasso. Transformer networks for trajectory forecasting. In International Conference on Pattern Recognition, 2020. [32] Ryan Sanford, Siavash Gorji, Luiz G Hafemann, Bahareh Pourbabaee, and Mehrsan Javan. Group activity detection from trajectory and video data in soccer. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pages 898– 899, 2020.   \n93 [33] Michael A. Alcorn and Anh Nguyen. baller2vec $^ { + + }$ : A look-ahead multi-entity transformer for modeling coordinated agents. arXiv preprint arXiv:2104.11980, 2021. ",
+        "bbox": [
+            148,
+            68,
+            828,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            153,
+            54,
+            828,
+            868
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            131
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] See Section 6.   \n(c) Did you discuss any potential negative societal impacts of your work? [No] Our work does not introduce new ethical challenges.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            239
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            243,
+            493,
+            258
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(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] ",
+        "bbox": [
+            238,
+            262,
+            735,
+            295
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            299,
+            393,
+            313
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A]   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] ",
+        "bbox": [
+            238,
+            316,
+            825,
+            435
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            220,
+            439,
+            823,
+            454
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [No] We link directly to the dataset.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            458,
+            823,
+            565
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            569,
+            705,
+            584
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            588,
+            825,
+            678
+        ],
+        "page_idx": 11
+    }
+]

parse/train/QRBvLayFXI/QRBvLayFXI.md

@@ -0,0 +1,257 @@
+# Revisiting the Calibration of Modern Neural Networks
+
+# Matthias Minderer Josip Djolonga Rob Romijnders Frances Hubis Xiaohua Zhai Neil Houlsby Dustin Tran Mario Lucic
+
+Google Research, Brain Team {mjlm, lucic}@google.com
+
+# Abstract
+
+Accurate estimation of predictive uncertainty (model calibration) is essential for the safe application of neural networks. Many instances of miscalibration in modern neural networks have been reported, suggesting a trend that newer, more accurate models produce poorly calibrated predictions. Here, we revisit this question for recent state-of-the-art image classification models. We systematically relate model calibration and accuracy, and find that the most recent models, notably those not using convolutions, are among the best calibrated. Trends observed in prior model generations, such as decay of calibration with distribution shift or model size, are less pronounced in recent architectures. We also show that model size and amount of pretraining do not fully explain these differences, suggesting that architecture is a major determinant of calibration properties.
+
+# 1 Introduction
+
+Neural networks, especially vision models, are increasingly used in safety-critical applications such as autonomous driving (Bojarski et al., 2016), medical diagnosis (Esteva et al., 2017; Jiang et al., 2012), and meteorological forecasting (Sønderby et al., 2020). For such applications, it is essential that model predictions are not just accurate, but also well calibrated. Model calibration refers to the accuracy with which the scores provided by the model reflect its predictive uncertainty. For example, in a medical application, we would like to defer images for which the model makes low-confidence predictions to a physician for review (Kompa et al., 2021). Skipping human review due to confident, but incorrect, predictions, could have disastrous consequences.
+
+While intense research and engineering effort has focused on improving the predictive accuracy of models, less attention has been given to model calibration. In fact, over the last few years, there have been many reports that calibration of modern neural networks can be surprisingly poor, despite the advances in accuracy (e.g. Guo et al. 2017; Lakshminarayanan et al. 2017; Malinin & Gales 2018; Thulasidasan et al. 2019; Hendrycks et al. 2020b; Ovadia et al. 2019; Wenzel et al. 2020; Havasi et al. 2021; Rahaman & Thiery 2020; Leathart & Polaczuk 2020). Some works suggest a trend for larger, more accurate models to be worse calibrated (Guo et al., 2017).
+
+These concerns are more relevant than ever, since the architecture size, amount of training data, and computing power used by state-of-the-art models continue to increase. At the same time, rapid advances in model architecture (Tolstikhin et al., 2021; Dosovitskiy et al., 2021) and training approaches (Chen et al., 2020; Mahajan et al., 2018; Radford et al., 2021) raise the question whether past results on calibration, largely obtained on standard convolutional architectures, extend to current state-of-the-art models. Since model advances are quickly translated to real-world, safety-critical applications (e.g. Mustafa et al. 2021), there is an urgent need to re-assess the calibration properties of current state-of-the-art models.
+
+Contributions. To address this need, we provide a systematic comparison of recent image classification models, relating their accuracy, calibration, and design features. We find that:
+
+1. The best current models, including the non-convolutional MLP-Mixer (Tolstikhin et al., 2021) and Vision Transformers (Dosovitskiy et al., 2021), are well calibrated compared to past models and their performance is more robust to distribution shift.   
+2. In-distribution calibration slightly deteriorates with increasing model size, but this is outweighed by a simultaneous improvement in accuracy.   
+3. Under distribution shift, calibration improves with model size, reversing the trend seen indistribution.   
+4. Accuracy and calibration are correlated under distribution shift, such that optimizing for accuracy may also benefit calibration.   
+5. Model size, pretraining duration, and pretraining dataset size cannot fully explain differences in calibration properties between model families.
+
+Our results suggest that further improvements in model accuracy will continue to benefit calibration. They also hint at architecture as an important determinant of model calibration. We provide code and a large dataset of calibration measurements, comprising 180 distinct models from 16 families, each evaluated on 79 ImageNet-scale datasets and 28 metric variants.1
+
+# 2 Related Work
+
+Measures of model calibration. The losses that are commonly used to train classification models, such as cross-entropy and squared error, are proper scoring rules (Gneiting et al., 2007) and are therefore guaranteed to yield perfectly calibrated models at their minimum—in the infinite-data limit. However, in practice, due to model mismatch and overfitting, even losses based on proper scoring rules may result in poor model calibration. Miscalibration is commonly quantified in terms of Expected Calibration Error (ECE; Naeini et al. 2015), which measures the absolute difference between predictive confidence and accuracy. We focus on ECE because it is a widely used and accepted calibration metric. Nevertheless, it is well understood that estimating ECE accurately is difficult because estimators can be strongly biased and many estimator variants exist (Nixon et al., 2019; Roelofs et al., 2020; Vaicenavicius et al., 2019; Gupta et al., 2021). Section 5 discusses these issues and our approaches to mitigate them.
+
+Alternatives to ECE include likelihood measures, Brier score (Brier, 1950), Bayesian methods (Gelman et al., 2013), and conformal prediction (Shafer & Vovk, 2008). Further, model calibration can be represented visually with reliability diagrams (DeGroot & Fienberg, 1983). Figure 8 and Appendix F provide likelihoods, Brier scores, and reliability diagrams for our main analyses.
+
+Empirical studies of model calibration. There have been many recent empirical studies on the robustness (accuracy under distribution shift) of image classifiers (Geirhos et al., 2019; Taori et al., 2020; Djolonga et al., 2020; Hendrycks et al., 2020a). Several works have also studied calibration. Most notable is Guo et al. (2017), who found that “modern neural networks, unlike those from a decade ago, are poorly calibrated”, that larger networks tend to be calibrated worse, and that “miscalibration worsen[s] even as classification error is reduced.” Other works have corroborated some of these findings (e.g., Thulasidasan et al. 2019; Wen et al. 2021). This line of work suggests a trend that larger models are worse calibrated, which would have major implications for research toward bigger models and datasets. We show that for more recent models, this trend is negligible in-distribution and in fact reverses under distribution shift.
+
+Ovadia et al. (2019) empirically study calibration under distribution shift and provide a large comparison of methods for improving calibration. They report that both accuracy and calibration deteriorate with distribution shift. While we observe the same trend, we find that the calibration of some recent model families decays so slowly under distribution shift that the decay in accuracy is likely more relevant in practice (Section 4.3).
+
+Ovadia et al. also find that, across methods for improving calibration, improvements on in-distribution data do not necessarily translate to out-of-distribution data. This finding may suggest that there is little correlation between in-distribution and out-of-distribution calibration in general. However, our results show that, across model architectures, the models with the best in-distribution calibration are also the best-calibrated on a range of out-of-distribution benchmarks. The important implication of this result is that designing models based on in-distribution performance likely also benefits their out-of-distribution performance.
+
+Improving calibration. Many strategies have been proposed to improve model calibration such as post-hoc rescaling of predictions (Guo et al., 2017), averaging multiple predictions (Lakshminarayanan et al., 2017; Wen et al., 2020), and data augmentation (Thulasidasan et al., 2019; Wen et al., 2021). Here, we focus on the intrinsic calibration properties of state-of-the-art model families, rather than methods to further improve calibration.
+
+As a baseline on top of a model’s intrinsic calibration properties, we study temperature scaling (Guo et al., 2017). It is effective in improving calibration and so simple that it can be applied in many cases at minimal additional cost, in contrast to many more sophisticated methods. Temperature scaling re-scales a model’s logits by a single parameter, chosen to optimize the model’s likelihood on a held-out portion of the training data. This temperature factor changes the model’s confidence, i.e., whether the model predictions are on average too certain (overconfident), optimally confident, or too uncertain (underconfident). The classification accuracy of the model is not affected by temperature scaling. A large fraction of model miscalibration is typically due to average over- or underconfidence, e.g. due to suboptimal training duration (Guo et al., 2017). By normalizing a model’s confidence, temperature scaling not only improves calibration, but also removes a primary confounder that can hide trends in calibration between models (see Section 4.2 and Appendix D). Therefore, we study both unscaled and temperature-scaled predictions in the paper.
+
+# 3 Definitions and Notation
+
+We consider the multi-class classification problem, as analyzed by Bröcker (2009), where we observe a variable $X$ and predict a categorical variable $Y \in \{ 1 , 2 , \dots , k \}$ . We model our predictor $f$ as a function that maps every input instance $X$ to a categorical distribution over $k$ labels, represented using a vector $f ( X )$ belonging to the $\left( k - 1 \right)$ -dimensional simplex $\Delta = \{ p \in [ 0 , 1 ] ^ { k } \mid \sum _ { y = 1 } ^ { k } p _ { y } = 1 \}$ .
+
+Intuitively, a model $f$ is well-calibrated if its output truthfully quantifies the predictive uncertainty. For example, if we take all data points $x$ for which the model predicts $[ f ( x ) ] _ { y } \stackrel { - } { = } 0 . 3$ , we expect $3 0 \%$ of them to indeed take on the label $y$ . Formally, the model $f$ is said to be calibrated if (Bröcker, 2009)
+
+$$
+\forall p \in \Delta \colon P ( Y = y \mid f ( X ) = p ) = p _ { y } .
+$$
+
+We will focus on a slightly weaker, but more practical condition, called top-label or argmax calibration (Kumar et al., 2019; Guo et al., 2017). This requires that the above holds only for the most likely label, i.e., $\forall p ^ { * } \in [ 0 , 1 ]$
+
+$$
+P ( Y \in \arg \operatorname* { m a x } { p } \mid \operatorname* { m a x } { f ( X ) } = p ^ { * } ) = p ^ { * } ,
+$$
+
+where the max and arg max act coordinate-wise.
+
+The most common measure of the degree of miscalibration is the Expected Calibration Error $( E C E )$ , which computes the expected disagreement between the two sides of eq. (2)
+
+$$
+\mathbb { E } \big [ | p ^ { * } - E [ Y \in \arg \operatorname* { m a x } f ( X ) \mid \operatorname* { m a x } f ( X ) = p ^ { * } | \big ] .
+$$
+
+Unfortunately, eq. (3) cannot be estimated without quantization as it conditions on a null event. Hence, one typically first buckets the predictions into $m$ bins $B _ { 1 } , \ldots , B _ { m }$ based on their top predicted probability, and then takes the expectation over these buckets. Namely, if we are given a set of $n$ i.i.d. samples $( x _ { 1 } , y _ { 1 } ) , \dotsc , ( x _ { n } , y _ { n } )$ distributed as $P ( X , Y )$ , then we assign each $\bar { \boldsymbol j } \in \{ 1 , \dots , n \}$ $B _ { i }$ n max  and th $f ( x _ { j } )$ . Tracy $B _ { i }$ nfidenc, where $( B _ { i } ) =$ $\begin{array} { r } { \frac { 1 } { | B _ { i } | } \sum _ { j \in B _ { i } } \operatorname* { m a x } f ( x _ { j } ) } \end{array}$ $\begin{array} { r } { \mathbf { \Gamma } ^ { \prime } ( B _ { i } ) = \frac { 1 } { | B _ { i } | } \sum _ { j \in B _ { i } } \mathbb { [ } y _ { j } \in \arg \operatorname* { m a x } f ( x _ { j } ) \mathbb { I } } \end{array}$ $[ [ \cdot ] ]$ Iverson bracket. Finally, we construct an estimator by taking the expectation over the bins
+
+$$
+{ \widehat { \mathrm { E C E } } } = \sum _ { i = 1 } ^ { m } { \frac { | B _ { i } | } { n } } \left| { \mathrm { a c c u r a c y } } ( B _ { i } ) - { \mathrm { c o n f i d e n c e } } ( B _ { i } ) \right| .
+$$
+
+In Section 5 we discuss the statistical properties of this estimator, possible pitfalls, and several mitigation strategies.
+
+![](images/d3873263ce65e780310aec7852fb074b4296d9234b239bed7aff776fb8b4ae9f.jpg)  
+Figure 1: Some modern neural network families are both highly accurate and well-calibrated. Left: Expected calibration error (ECE) vs. classification error on IMAGENET for state-of-the-art image classification models. Marker size indicates relative model size within its family. Points labeled “Guo et al.” are the values reported for DenseNet-161 and ResNet-152 in Guo et al. (2017). Right: Confidence distribution (top row) and reliability diagrams (bottom row) for some of the models.
+
+# 4 Empirical Evaluation
+
+# 4.1 Experimental Setup
+
+Model families. In this study, we consider a range of recent and some historic state-of-the-art image classification models. Our selection of models covers convolutional and non-convolutional architectures, as well as supervised, weakly supervised, unsupervised and zero-shot training. We follow the original publications in naming the model variants within each family (e.g. different model sizes). See Appendix A.1 for a detailed description of all used models.
+
+1. MLP-Mixer (Tolstikhin et al., 2021) is based exclusively on multi-layer perceptrons (MLPs) and is pre-trained on large supervised datasets.   
+2. ViT (Dosovitskiy et al., 2021) processes images with a transformer architecture originally designed for language (Vaswani et al., 2017) and is also pre-trained on large supervised datasets.   
+3. BiT (Kolesnikov et al., 2020) is a ResNet-based architecture (He et al., 2016). It is also pre-trained on large supervised datasets.   
+4. ResNext-WSL (Mahajan et al., 2018) is based on the ResNeXt architecture and trained with weak supervision from billions of hashtags on social media images.   
+5. SimCLR (Chen et al., 2020) is a ResNet, pretrained with an unsupervised contrastive loss.   
+6. CLIP (Radford et al., 2021) is pretrained on raw text and imagery using a contrastive loss.   
+7. AlexNet (Krizhevsky et al., 2012; Krizhevsky, 2014) was the first convolutional neural network to win the ImageNet challenge.
+
+All models are either trained or fine-tuned on the IMAGENET training set, except for CLIP, which makes zero-shot predictions using IMAGENET class names as queries.
+
+Datasets. We evaluate accuracy and calibration on the IMAGENET validation set and the following out-of-distribution benchmarks using the Robustness Metrics library (Djolonga et al., 2020):
+
+1. IMAGENETV2 (Recht et al., 2019) is a new IMAGENET test set collected by closely following the original IMAGENET labeling protocol.   
+2. IMAGENET-C (Hendrycks & Dietterich, 2019) consists of the images from IMAGENET, modified with synthetic perturbations such as blur, pixelation, and compression artifacts at a range of severities.   
+3. IMAGENET-R (Hendrycks et al., 2020a) contains artificial renditions of IMAGENET classes such as art, cartoons, drawings, sculptures, and others.   
+4. IMAGENET-A (Hendrycks et al., 2021) contains images that are classified as belonging to IMAGENET classes by humans, but adversarially selected to be hard to classify for a ResNet50 trained on IMAGENET.
+
+For the post-hoc recalibration of models, we reserve $20 \%$ of the IMAGENET validation set (randomly sampled) for fitting the temperature scaling parameter. All reported metrics are computed on the remaining $80 \%$ of the data. For evaluations on IMAGENET-C, we also exclude the $20 \%$ of images that are based on the IMAGENET images used for temperature scaling.
+
+Calibration metric. Throughout the paper, we estimate ECE using equal-mass binning and 100 bins. Appendix E shows that our results hold for other ECE variants and are consistent with the Brier score and model likelihood.
+
+# 4.2 In-Distribution Calibration
+
+We begin by considering ECE on clean IMAGENET images (referred to as in-distribution). Figure 1 shows in-distribution ECE and reliability diagrams before any recalibration of the predicted probabilities. We find that several recent model families (MLP-Mixer, ViT, and BiT) are both highly accurate and well-calibrated compared to prior models, such as AlexNet or the models studied by Guo et al. (2017). This suggests that there may be no continuing trend for highly accurate modern neural networks to be poorly calibrated, as suggested previously (Guo et al., 2017; Lakshminarayanan et al., 2017; Malinin & Gales, 2018; Thulasidasan et al., 2019; Hendrycks et al., 2020b; Ovadia et al., 2019; Wenzel et al., 2020; Havasi et al., 2021; Rahaman & Thiery, 2020; Leathart & Polaczuk, 2020). In addition, we find that a recent zero-shot model, CLIP, is well-calibrated given its accuracy.
+
+Temperature scaling reveals consistent properties of model families. The poor calibration of past models can often be remedied by post-hoc recalibration such as temperature scaling (Guo et al., 2017), which raises the question whether a difference between models remains after recalibration. We find that the most recent architectures are better calibrated than past models even after temperature scaling (Figure 2, right).
+
+More generally, temperature scaling reveals consistent trends in the calibration properties between families that are obscured in the unscaled data by simple over- or underconfidence miscalibration. Before temperature scaling (Figure 2, left), several families overlap in their accuracy/calibration properties (MLP-Mixer, ViT, BiT). After temperature scaling (Figure 2, right), a clearer separation of families and consistent trends between accuracy and calibration within each family become apparent. Notably, temperature scaling reconciles our results for BiT (a ResNet architecture) with the results reported by Guo et al. for ResNets trained on IMAGENET. Furthermore, models pretrained without addi
+
+![](images/7be6364f70c451e752fc05f4f0702ef975baa8db00ee92ad42e0203616c5f878.jpg)  
+Figure 2: Temperature scaling reveals consistent properties of model families. Left: ECE vs. classification error as in Figure 1. Right: ECE after applying temperature scaling.
+
+tional labels (SimCLR) or with noisy labels (ResNeXt-WSL) tend to be calibrated worse for a given accuracy than ResNets trained with supervision (BiT and the models studied by Guo et al.). Finally, non-convolutional model families like MLP-Mixer and ViT can perform just as well, if not better, than convolutional ones.
+
+Differences between families are not explained by model size or pretraining amount. We next attempt to disentangle how the differences between model families affect their calibration properties. We focus on model size and amount of pretraining, both important trends in state of-the-art models.
+
+We first consider model size. Prior work has suggested that larger neural networks are worse calibrated (Guo et al., 2017). We also find that within most families, larger members tend to have higher calibration error (Figure 2, right). However, at the same time, larger models have consistently lower classification error. This means that each model family occupies a different Pareto set in the tradeoff between accuracy and calibration. For example, our results suggest that, at any given accuracy, ViT models are better calibrated than BiT models. Changing the size of a BiT model cannot move it into the Pareto set of ViT models. Model size can therefore not fully explain the intrinsic calibration differences between these model families.2
+
+We next consider model pretraining. Many current state-of-the-art image models use transfer learning, in which a model is pre-trained on a large dataset and then fine-tuned to the task of interest (Kolesnikov et al., 2020; Chen et al., 2020; Xie et al., 2020). With transfer learning, large data sources can be exploited to train the model, even if little data are available for the final task. To test how the amount of pretraining affects calibration, we compare BiT models pretrained on IMAGENET (1.3M images), IMAGENET-21K (12.8M images), or JFT-300 (300M images; Sun et al. 2017).
+
+More pretraining data consistently increases accuracy, especially for larger models. It has no consistent effect on calibration (Figure 3). In particular, after temperature scaling, ECE is essentially unchanged across this 300-fold increase in pretraining dataset size (e.g. for BiTR50x1 pretrained on IMAGENET, IMAGENET21K and JFT-300, the ECEs are 0.0185, 0.0182, 0.0185, respectively; for BiT-R101x3, they are 0.0272, 0.0311, 0.0236; Figure 3, bottom). Therefore, regardless of the pretraining dataset, BiT always remains Pareto-dominant over SimCLR and Pareto-dominated by ViT and MLPMixer in our experiments.
+
+The BiT models compared in Figure 3 differ in both the amount of pretraining data and the duration of pretraining (see Kolesnikov et al. (2020) for details). To further disentangle these variables, we trained BiT models on varying numbers of pretraining examples while holding the number of training steps constant, and vice versa. We find that pretraining dataset size has no significant effect on calibration, while pretraining duration only shifts the model within its accuracy/calibration Pareto set (longer-trained models are more accurate and worse calibrated; Figure 10). These results suggest that pretraining alone cannot explain the differences between model families that we observe.
+
+![](images/e0612eaa30c873581b31c32f299479b5cd52f7e19aadbbb95b216b9d1360de43.jpg)  
+Figure 3: Family differences are not fully explained by the amount of pretraining. Each column shows ECE vs. classification error on ImageNet for BiT models pre-trained with a different dataset: IMAGENET (1.3M images), IMAGENET-21K (12.8M images), or JFT-300 (300M images). The values for other models are provided for reference in light shading (same values as in Figure 2). Note how all BiT models remain in the same relative location between ViT and SimCLR across a 300-fold difference in pretraining data size.
+
+In summary, our results show that some modern neural network families combine high accuracy and state-of-the-art calibration on in-distribution data, both before and after post-hoc recalibration by temperature scaling. In Figure 8 and Appendices E and F, we show that these results generally hold for other measures of model calibration (other ECE variants, Brier score, and model likelihood). Our experiments further suggest that model size and pretraining amount do not fully explain the intrinsic calibration differences between model families. Given that the best-calibrated families (MLP-Mixer and ViT) are non-convolutional, we speculate that model architecture, and in particular its spatial inductive bias, play an important role.
+
+# 4.3 Accuracy and Calibration Under Distribution Shift
+
+For safety-critical applications, the model should produce reasonable uncertainty estimates not just in-distribution, but also under distribution shifts that were not anticipated at training time. We first assess out-of-distribution calibration on the IMAGENET-C dataset, which consists of images that have been synthetically corrupted at five different severities. As expected, both classification and calibration error generally increase with distribution shift (Figure 4; Ovadia et al. 2019; Hendrycks & Dietterich 2019). Interestingly, this decay in calibration performance is slower for MLP-Mixer and ViT than for the other model families, both before and after temperature scaling.
+
+Regarding the effect of model size on calibration, we observed some trend towards worse calibration of larger models on in-distribution data. However, the trend is reversed for most model families as we move out of distribution, especially after accounting for confidence bias by temperature scaling (note positive slope of the gray lines at high corruption severities in Figure 4, bottom row). In other words, the calibration of larger models is more robust to distribution shift (Figure 5).
+
+![](images/1d3f1e8b7d26bdfb208d0c65d3ef6e1916c839d954b1c192e7a7255065ff598c.jpg)  
+Figure 4: Calibration and accuracy on IMAGENET-C before (top) and after (bottom) temperature scaling on IMAGENET. Severity 0 refers to the clean IMAGENET test set; marker size indicates relative model size within its family (see Table 1 for model details). The calibration of some recent model families, e.g. MLP-Mixer and ViT, is more robust to distribution shift than past models.
+
+We next consider to what degree the insights from in-distribution and IMAGENET-C calibration transfer to natural out-of-distribution data. Previous work on IMAGENET-C suggests that, when comparing recalibration methods, better in-distribution calibration and accuracy do not usually predict better calibration under distribution shift (Ovadia et al., 2019). Here, comparing model families, we find that the performance on several natural out-of-distribution datasets is largely consistent with that on IMAGENET (Figure 6). In particular, models that are Pareto-optimal (i.e. no other model is both more accurate and better calibrated) on IMAGENET remain Pareto-optimal on the OOD datasets. Further, we observe a strong correlation between accuracy and calibration on the OOD datasets. This relationship is consistent across models within a family and across datasets, over a wide range of accuracies (Figure 11).
+
+These results suggest that larger and more accurate models, and in particular MLP-Mixer and ViT, can maintain their good in-distribution calibration even under severe distribution shifts. Based on the observed relationship between calibration and accuracy, we can reasonably hope that good calibration on in-distribution data (and anticipated distribution shifts) generally translates into good calibration on unanticipated outof-distribution data, similar to what has been observed for accuracy (Djolonga et al., 2020).
+
+# 4.4 Relating Accuracy and Calibration Within Model Families
+
+Our data suggest that most model families lie on different Pareto sets in the accuracy/calibration space, which establishes a clear preference between families. We next consider how to compare individual models within a family (or more specifically, within a Pareto set), where one model is more accurate but worse calibrated, and the other is less accurate but better calibrated. Which model should a practitioner choose for a safety-critical application?
+
+![](images/d76d583138787f2a8a5c51e8aeea92feb7a3d544aed6c3391b3fdd4c20582f6a.jpg)  
+Figure 5: Classification error and ECE for the top three families on IMAGENET-C, relative to the largest model variant in each family. As distribution shift increases, both errors tend to increase more slowly for larger models. Also note that changes in ECE are much smaller than changes in classification error.
+
+![](images/6820bf8fd2a4bab04d2ea4c0b78c65f0ad2da759aced17e74a5948293ffcc419.jpg)  
+Figure 6: Calibration and accuracy before (top row) and after (bottom row) temperature scaling on out-of-distribution benchmarks. Marker size indicates relative model size within its family. IMAGENET-R and IMAGENET-A use a reduced subset of 200 classes; we follow the literature and select the subset of the model logits for these classes before evaluation. Out-of-distribution calibration tends to correlate with in-distribution calibration (Figure 1) and out-of-distribution accuracy.
+
+The answer depends on the cost structure of the specific application (Hernández-Orallo et al., 2012). As an example, consider the scenario of selective prediction, which is common in medical diagnosis. In this task, one can choose to ignore the model prediction (“abstain”) at a fixed cost if the prediction confidence is low, rather than risking a (more costly) prediction error.
+
+Figure 7 compares the expected cost for two BiT variants, one with better classification error $( \mathrm { R } 1 5 2 \mathrm { x } 4 $ , by 0.08), and one with better ECE (R50x1, by 0.009). For abstention rates up to $70 \%$ (which covers most practical scenarios with abstention rates low enough for the model to be useful), the model with better accuracy has a lower overall cost than the model with better ECE. The same is true for all other model families we study (Appendix B.3). For these families and this cost scenario, a practitioner should therefore always choose the most accu
+
+![](images/cfa32322a95ce2977cd5a22d547acc5ef1b9158786cdcf462dfa3c3324fb13b7.jpg)  
+Figure 7: Relative cost of BiT-R $1 5 2 \mathrm { x } 4$ and BiT$\mathrm { R } 5 0 \mathrm { x } 1$ models in a selective prediction scenario, computed as a combination of the misclassification and abstention costs at a given cost ratio $\mathbf { \dot { x } }$ -axis) and abstention rate (y-axis). Blue indicates regions where the higher-accuracy model $( \mathrm { R } 1 5 2 \mathrm { x } 4 )$ achieves a lower cost than the bettercalibrated model (R50x1). The accuracy advantage outweighs the calibration advantage for practical rejection rates, across all tested abstention costs.
+
+rate available model regardless of differences in calibration. Ultimately, real-world cost structures are complex and may yield different results; Figure 7 presents one common scenario with downstream ramifications for the importance of the calibration differences compared to accuracy.
+
+# 5 Pitfalls and Limitations
+
+For this study, we approached calibration with a simple, practical question: Given two models, one more accurate and the other better calibrated, which should a practitioner choose? While working towards answering this question, we encountered several pitfalls that complicate the interpretation of calibration results.
+
+Measuring calibration is challenging, and while the quantity we want to estimate is well specified, the estimator itself can be biased. There are two sources of bias: (i) from estimating ECE by binning, and (ii) from the finite sample size used to estimate the per-bin statistics.
+
+![](images/9db148e6dc3909c486ef77ec646f6fad8a42681b75c2ad3563bc5b379711c097.jpg)  
+Figure 8: Alternative calibration metrics: negative log-likelihood (NLL) and Brier score. For comparison, the first row shows ECE as in Figure 6. Since NLL, Brier score, and classification error are all highly correlated, we also provide the residuals of NLL and Brier score after regressing out classification error (third and fifth row). Specifically, we first fit a linear regression $y _ { i } = \beta _ { 0 } + \beta _ { 1 } x _ { i }$ , where $x _ { i }$ is the classification error and $y _ { i }$ is the calibration measure of model $i$ . We then report the residual $y _ { i } - \left( \beta _ { 0 } + \beta _ { 1 } x _ { i } \right)$ on the $y$ -axis of the plots in the third and fifth row. The residuals show which models have better (or worse) NLL and Brier score than what can be expected from their accuracy alone. The relationships between model families are largely similar across all calibration metrics.
+
+The first of these biases is always negative (Kumar et al., 2019), while the second one is always positive. Thus, the estimator can both under- and over-estimate the true value, and the magnitude of the bias can depend on multiple factors. In practice, this means that the ranking of models depends on which ECE variant is chosen to estimate calibration (Nixon et al., 2019). As we show below, this is especially problematic for the positive bias, because this bias depends on the accuracy of the model. It is therefore possible to arrive at opposite conclusions about the relationship between accuracy and calibration, depending on the chosen bin size (Figure 9), especially when comparing models with widely varying accuracies.
+
+Intuitively, a larger number of bins implies fewer points per bin and thus higher variance of the estimate of the model accuracy in each bin, which adds positive bias to the estimate of ECE. More formally, to estimate accuracy $( B _ { i } )$ precisely, we need a number of samples inversely proportional to the standard deviation $\sqrt { p _ { i } ( 1 - p _ { i } ) } / | B _ { i } |$ , where $p _ { i }$ is the expected accuracy in $B _ { i }$ . This indicates that the bias would be smaller for models with extreme average accuracies (i.e. close to 0 or 1) and larger for models with an accuracy close to 0.5. A detailed analysis reveals additional effects that further reduce the bias for higher-accuracy models (Appendix C). In particular, if we estimate $( \mathbb { E } [ \mathrm { a c c u r a c y } ( B _ { i } ) ] - \mathbb { E } [ \mathrm { \bar { c } o n f i d e n c e } ( B _ { i } ) ] ) ^ { 2 }$ for any bin $i$ with $n _ { i }$ samples (using the sample means of the confidences and the accuracies), the bias can be shown to be equal to (conditioning on $X \in B _ { i }$ omitted for brevity)
+
+![](images/a4030819ad6555c65f3667055cf16acf6245c9c6d1ca04a6cb15713a840d04f0.jpg)  
+Figure 9: The effect of binning-induced bias in ECE depends on accuracy. Each dot represents a BiT ResNet model. Plotted models differ in model size, pretraining dataset size, and pretraining duration. All models are fine-tuned and evaluated on IMAGENET. After temperature scaling, there is a near-linear relationship between ECE and classification error. However, whether this relationship is positive or negative depends on the number of bins used for estimating ECE. This effect is explained by an accuracy-dependent bias that increases with the number of bins.
+
+$$
+\frac { 1 } { n _ { i } } ( \mathbb { V } [ A ] + \mathbb { V } [ C ] - 2 { \bf C o v } [ C , A ] ) ,
+$$
+
+where $A = [ [ Y \in \arg \operatorname* { m a x } { f ( X ) } ] ]$ and $C = \operatorname* { m a x } f ( X )$ . Hence, from Equation 5 we can conclude J Kthat higher accuracy models have a lower bias not only due to higher accuracy (lower $\mathbb { V } [ A ] )$ , but also because their outputs correlate more with the correct label (higher covariance).
+
+In addition to a careful choice of bin size, considering accuracy and calibration jointly mitigates this issue, because the Pareto-optimal models rarely change, even if the ranking based on ECE alone does (Appendix E). In Appendices E and F, we provide the main figures of the paper for other ECE variants (number of bins, binning scheme, normalization metric, top-label, all-label, class-wise).
+
+Finally, metrics such as Brier score (Brier, 1950) and likelihood provide alternative assessments of model calibration that do not require estimating expected calibration error. We find that the relationships between model families are consistent across ECE, NLL and Brier score (Figure 8). In particular, the same models (specifically the largest MLP-Mixer and ViT variants) remain Paretooptimal with respect to the calibration metric and classification error in most cases. The relationship between models is visualized especially clearly after regressing out from the calibration metrics their correlation with classification error (Figure 8, third and fifth row).
+
+# 6 Conclusion
+
+We performed a large study of the calibration of recent state-of-the-art image models and its relationship with accuracy. We find that modern image models are well calibrated across distribution shifts despite being designed with a focus on accuracy. Our results suggest that there is no general trend for recent or highly accurate neural networks to be poorly calibrated compared to older or less accurate models.
+
+Our experiments suggest that simple dimensions such as model size and pretraining amount do not fully account for the performance differences between families, pointing towards architecture as a major determinant of calibration. Of particular note is the finding that MLP-Mixer and Vision Transformers—two recent architectures that are not based on convolutions—are among the best-calibrated models both in-distribution and out-of-distribution. Self-attention (which Vision Transformers employ heavily) has been shown previously to be beneficial for certain kinds of outof-distribution robustness (Hendrycks et al., 2020a). Our work now hints at calibration benefits of non-convolutional architectures more broadly, for certain kinds of distribution shift. Further work on the influence of architectural inductive biases on calibration and out-of-distribution robustness will be necessary to tell whether these results generalize. If so, they may further hasten the end of the convolutional era in computer vision.
+
+# Acknowledgments and Disclosure of Funding
+
+We thank Carlos Riquelme and Balaji Lakshminarayanan for valuable comments on the manuscript.   
+The authors declare no competing interests.   
+References   
+Bojarski, M., Del Testa, D., Dworakowski, D., Firner, B., Flepp, B., Goyal, P., Jackel, L. D., Monfort, M., Muller, U., Zhang, J., et al. End to end learning for self-driving cars. arXiv: 1604.07316, 2016.   
+Brier, G. W. Verification of forecasts expressed in terms of probability. Monthly weather review, 1950.   
+Bröcker, J. Reliability, sufficiency, and the decomposition of proper scores. Journal of the Royal Meteorological Society, 2009.   
+Chen, T., Kornblith, S., Norouzi, M., and Hinton, G. E. A simple framework for contrastive learning of visual representations. In International Conference on Machine Learning, 2020.   
+DeGroot, M. H. and Fienberg, S. E. The comparison and evaluation of forecasters. Journal of the Royal Statistical Society, 1983.   
+Deng, J., Dong, W., Socher, R., Li, L.-J., Li, K., and Fei-Fei, L. Imagenet: A large-scale hierarchical image database. In Conference on Computer Vision and Pattern Recognition, 2009.   
+Djolonga, J., Matthias, M., Nado, Z., Nixon, J., Romijnders, R., Tran, D., and Lucic, M. Robustness Metrics, 2020. URL https://github.com/google-research/robustness_metrics.   
+Dosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn, D., Zhai, X., Unterthiner, T., Dehghani, M., Minderer, M., Heigold, G., Gelly, S., Uszkoreit, J., and Houlsby, N. An image is worth 16x16 words: Transformers for image recognition at scale. In International Conference on Learning Representations, 2021.   
+Esteva, A., Kuprel, B., Novoa, R. A., Ko, J., Swetter, S. M., Blau, H. M., and Thrun, S. Dermatologistlevel classification of skin cancer with deep neural networks. Nature, 2017.   
+Geirhos, R., Rubisch, P., Michaelis, C., Bethge, M., Wichmann, F. A., and Brendel, W. Imagenettrained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness. In International Conference on Learning Representations, 2019.   
+Gelman, A., Carlin, J. B., Stern, H. S., Dunson, D. B., Vehtari, A., and Rubin, D. B. Bayesian data analysis. CRC press, 2013.   
+Gneiting, T., Balabdaoui, F., and Raftery, A. E. Probabilistic forecasts, calibration and sharpness. Journal of the Royal Statistical Society, 2007.   
+Guo, C., Pleiss, G., Sun, Y., and Weinberger, K. Q. On calibration of modern neural networks. In International Conference on Machine Learning, 2017.   
+Gupta, K., Rahimi, A., Ajanthan, T., Mensink, T., Sminchisescu, C., and Hartley, R. Calibration of neural networks using splines. International Conference on Learning Representations, 2021.   
+Havasi, M., Jenatton, R., Fort, S., Liu, J. Z., Snoek, J., Lakshminarayanan, B., Dai, A. M., and Tran, D. Training independent subnetworks for robust prediction. In International Conference on Learning Representations, 2021.   
+He, K., Zhang, X., Ren, S., and Sun, J. Identity mappings in deep residual networks. In European Conference on Computer Vision, 2016.   
+Hendrycks, D. and Dietterich, T. Benchmarking neural network robustness to common corruptions and perturbations. In International Conference on Learning Representations, 2019.   
+Hendrycks, D., Basart, S., Mu, N., Kadavath, S., Wang, F., Dorundo, E., Desai, R., Zhu, T., Parajuli, S., Guo, M., et al. The many faces of robustness: A critical analysis of out-of-distribution generalization. arXiv: 2006.16241, 2020a.   
+Hendrycks, D., Mu, N., Cubuk, E. D., Zoph, B., Gilmer, J., and Lakshminarayanan, B. Augmix: A simple data processing method to improve robustness and uncertainty. In International Conference on Learning Representations, 2020b.   
+Hendrycks, D., Zhao, K., Basart, S., Steinhardt, J., and Song, D. Natural adversarial examples. In Conference on Computer Vision and Pattern Recognition, 2021.   
+Hernández-Orallo, J., Flach, P. A., and Ferri, C. A unified view of performance metrics: translating threshold choice into expected classification loss. Journal of Machine Learning Research, 2012.   
+Jiang, X., Osl, M., Kim, J., and Ohno-Machado, L. Calibrating predictive model estimates to support personalized medicine. Journal of the American Medical Informatics Association, 2012.   
+Kolesnikov, A., Beyer, L., Zhai, X., Puigcerver, J., Yung, J., Gelly, S., and Houlsby, N. Big transfer (bit): General visual representation learning. In European Conference on Computer Vision, 2020.   
+Kompa, B., Snoek, J., and Beam, A. L. Second opinion needed: communicating uncertainty in medical machine learning. NPJ Digital Medicine, 2021.   
+Krizhevsky, A. One weird trick for parallelizing convolutional neural networks. arXiv: 1404.5997, 2014.   
+Krizhevsky, A., Sutskever, I., and Hinton, G. E. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems, 2012.   
+Kumar, A., Liang, P. S., and Ma, T. Verified uncertainty calibration. In Advances in Neural Information Processing Systems, 2019.   
+Lakshminarayanan, B., Pritzel, A., and Blundell, C. Simple and scalable predictive uncertainty estimation using deep ensembles. In Advances in Neural Information Processing Systems, 2017.   
+Leathart, T. and Polaczuk, M. Temporal probability calibration. arXiv: 2002.02644, 2020.   
+Mahajan, D., Girshick, R. B., Ramanathan, V., He, K., Paluri, M., Li, Y., Bharambe, A., and van der Maaten, L. Exploring the limits of weakly supervised pretraining. In European Conference on Computer Vision, 2018.   
+Malinin, A. and Gales, M. J. F. Predictive uncertainty estimation via prior networks. In Advances in Neural Information Processing Systems, 2018.   
+Müller, R., Kornblith, S., and Hinton, G. E. When does label smoothing help? In Advances in Neural Information Processing Systems, 2019.   
+Mustafa, B., Loh, A., Freyberg, J., MacWilliams, P., Wilson, M., McKinney, S. M., Sieniek, M., Winkens, J., Liu, Y., Bui, P., Prabhakara, S., Telang, U., Karthikesalingam, A., Houlsby, N., and Natarajan, V. Supervised transfer learning at scale for medical imaging. arXiv: 2101.05913, 2021.   
+Naeini, M. P., Cooper, G., and Hauskrecht, M. Obtaining well calibrated probabilities using bayesian binning. In AAAI Conference on Artificial Intelligence, 2015.   
+Nixon, J., Dusenberry, M. W., Zhang, L., Jerfel, G., and Tran, D. Measuring calibration in deep learning. In IEEE Conference on Computer Vision and Pattern Recognition Workshops, 2019.   
+Ovadia, Y., Fertig, E., Lakshminarayanan, B., Nowozin, S., Sculley, D., Dillon, J. V., Ren, J., Nado, Z., and Snoek, J. Can you trust your model’s uncertainty? evaluating predictive uncertainty under dataset shift. In Advances in Neural Information Processing Systems, 2019.   
+Radford, A., Kim, J. W., Hallacy, C., Ramesh, A., Goh, G., Agarwal, S., Sastry, G., Askell, A., Mishkin, P., Clark, J., et al. Learning transferable visual models from natural language supervision. Technical report, OpenAI, 2021.   
+Rahaman, R. and Thiery, A. H. Uncertainty quantification and deep ensembles. arXiv: 2007.08792, 2020.
+
+Recht, B., Roelofs, R., Schmidt, L., and Shankar, V. Do imagenet classifiers generalize to imagenet? In International Conference on Machine Learning, 2019.   
+Roelofs, R., Cain, N., Shlens, J., and Mozer, M. C. Mitigating bias in calibration error estimation. arXiv: 2012.08668, 2020.   
+Shafer, G. and Vovk, V. A tutorial on conformal prediction. Journal of Machine Learning Research, 2008.   
+Sønderby, C. K., Espeholt, L., Heek, J., Dehghani, M., Oliver, A., Salimans, T., Agrawal, S., Hickey, J., and Kalchbrenner, N. Metnet: A neural weather model for precipitation forecasting. arXiv: 2003.12140, 2020.   
+Sun, C., Shrivastava, A., Singh, S., and Gupta, A. Revisiting unreasonable effectiveness of data in deep learning era. In International Conference on Computer Vision, 2017.   
+Szegedy, C., Vanhoucke, V., Ioffe, S., Shlens, J., and Wojna, Z. Rethinking the inception architecture for computer vision. In Conference on Computer Vision and Pattern Recognition, 2016.   
+Taori, R., Dave, A., Shankar, V., Carlini, N., Recht, B., and Schmidt, L. Measuring robustness to natural distribution shifts in image classification. Advances in Neural Information Processing Systems, 2020.   
+Thulasidasan, S., Chennupati, G., Bilmes, J. A., Bhattacharya, T., and Michalak, S. On mixup training: Improved calibration and predictive uncertainty for deep neural networks. In Advances in Neural Information Processing Systems, 2019.   
+Tolstikhin, I., Houlsby, N., Kolesnikov, A., Beyer, L., Zhai, X., Unterthiner, T., Yung, J., Steiner, A., Keysers, D., Uszkoreit, J., Lucic, M., and Dosovitskiy, A. MLP-Mixer: An all-MLP architecture for vision. arXiv: 2105.01601, 2021.   
+Vaicenavicius, J., Widmann, D., Andersson, C. R., Lindsten, F., Roll, J., and Schön, T. B. Evaluating model calibration in classification. In International Conference on Artificial Intelligence and Statistics, 2019.   
+Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, L., and Polosukhin, I. Attention is all you need. In Advances in Neural Information Processing Systems, 2017.   
+Wen, Y., Tran, D., and Ba, J. Batchensemble: an alternative approach to efficient ensemble and lifelong learning. In Advances in Neural Information Processing Systems, 2020.   
+Wen, Y., Jerfel, G., Muller, R., Dusenberry, M. W., Snoek, J., Lakshminarayanan, B., and Tran, D. Combining ensembles and data augmentation can harm your calibration. In International Conference on Learning Representations, 2021.   
+Wenzel, F., Snoek, J., Tran, D., and Jenatton, R. Hyperparameter ensembles for robustness and uncertainty quantification. In Advances in Neural Information Processing Systems, 2020.   
+Xie, Q., Luong, M.-T., Hovy, E., and Le, Q. V. Self-training with noisy student improves imagenet classification. In Conference on Computer Vision and Pattern Recognition, 2020.

parse/train/QRBvLayFXI/QRBvLayFXI_content_list.json

@@ -0,0 +1,1063 @@
+[
+    {
+        "type": "text",
+        "text": "Revisiting the Calibration of Modern Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            326,
+            122,
+            673,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Matthias Minderer Josip Djolonga Rob Romijnders Frances Hubis Xiaohua Zhai Neil Houlsby Dustin Tran Mario Lucic ",
+        "text_level": 1,
+        "bbox": [
+            238,
+            220,
+            758,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Google Research, Brain Team {mjlm, lucic}@google.com ",
+        "bbox": [
+            397,
+            253,
+            602,
+            285
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            320,
+            535,
+            337
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Accurate estimation of predictive uncertainty (model calibration) is essential for the safe application of neural networks. Many instances of miscalibration in modern neural networks have been reported, suggesting a trend that newer, more accurate models produce poorly calibrated predictions. Here, we revisit this question for recent state-of-the-art image classification models. We systematically relate model calibration and accuracy, and find that the most recent models, notably those not using convolutions, are among the best calibrated. Trends observed in prior model generations, such as decay of calibration with distribution shift or model size, are less pronounced in recent architectures. We also show that model size and amount of pretraining do not fully explain these differences, suggesting that architecture is a major determinant of calibration properties. ",
+        "bbox": [
+            233,
+            353,
+            764,
+            505
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            537,
+            310,
+            555
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural networks, especially vision models, are increasingly used in safety-critical applications such as autonomous driving (Bojarski et al., 2016), medical diagnosis (Esteva et al., 2017; Jiang et al., 2012), and meteorological forecasting (Sønderby et al., 2020). For such applications, it is essential that model predictions are not just accurate, but also well calibrated. Model calibration refers to the accuracy with which the scores provided by the model reflect its predictive uncertainty. For example, in a medical application, we would like to defer images for which the model makes low-confidence predictions to a physician for review (Kompa et al., 2021). Skipping human review due to confident, but incorrect, predictions, could have disastrous consequences. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            681
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While intense research and engineering effort has focused on improving the predictive accuracy of models, less attention has been given to model calibration. In fact, over the last few years, there have been many reports that calibration of modern neural networks can be surprisingly poor, despite the advances in accuracy (e.g. Guo et al. 2017; Lakshminarayanan et al. 2017; Malinin & Gales 2018; Thulasidasan et al. 2019; Hendrycks et al. 2020b; Ovadia et al. 2019; Wenzel et al. 2020; Havasi et al. 2021; Rahaman & Thiery 2020; Leathart & Polaczuk 2020). Some works suggest a trend for larger, more accurate models to be worse calibrated (Guo et al., 2017). ",
+        "bbox": [
+            174,
+            688,
+            825,
+            785
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "These concerns are more relevant than ever, since the architecture size, amount of training data, and computing power used by state-of-the-art models continue to increase. At the same time, rapid advances in model architecture (Tolstikhin et al., 2021; Dosovitskiy et al., 2021) and training approaches (Chen et al., 2020; Mahajan et al., 2018; Radford et al., 2021) raise the question whether past results on calibration, largely obtained on standard convolutional architectures, extend to current state-of-the-art models. Since model advances are quickly translated to real-world, safety-critical applications (e.g. Mustafa et al. 2021), there is an urgent need to re-assess the calibration properties of current state-of-the-art models. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Contributions. To address this need, we provide a systematic comparison of recent image classification models, relating their accuracy, calibration, and design features. We find that: ",
+        "bbox": [
+            174,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. The best current models, including the non-convolutional MLP-Mixer (Tolstikhin et al., 2021) and Vision Transformers (Dosovitskiy et al., 2021), are well calibrated compared to past models and their performance is more robust to distribution shift.   \n2. In-distribution calibration slightly deteriorates with increasing model size, but this is outweighed by a simultaneous improvement in accuracy.   \n3. Under distribution shift, calibration improves with model size, reversing the trend seen indistribution.   \n4. Accuracy and calibration are correlated under distribution shift, such that optimizing for accuracy may also benefit calibration.   \n5. Model size, pretraining duration, and pretraining dataset size cannot fully explain differences in calibration properties between model families. ",
+        "bbox": [
+            194,
+            126,
+            826,
+            279
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our results suggest that further improvements in model accuracy will continue to benefit calibration. They also hint at architecture as an important determinant of model calibration. We provide code and a large dataset of calibration measurements, comprising 180 distinct models from 16 families, each evaluated on 79 ImageNet-scale datasets and 28 metric variants.1 ",
+        "bbox": [
+            176,
+            285,
+            825,
+            339
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            359,
+            321,
+            376
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Measures of model calibration. The losses that are commonly used to train classification models, such as cross-entropy and squared error, are proper scoring rules (Gneiting et al., 2007) and are therefore guaranteed to yield perfectly calibrated models at their minimum—in the infinite-data limit. However, in practice, due to model mismatch and overfitting, even losses based on proper scoring rules may result in poor model calibration. Miscalibration is commonly quantified in terms of Expected Calibration Error (ECE; Naeini et al. 2015), which measures the absolute difference between predictive confidence and accuracy. We focus on ECE because it is a widely used and accepted calibration metric. Nevertheless, it is well understood that estimating ECE accurately is difficult because estimators can be strongly biased and many estimator variants exist (Nixon et al., 2019; Roelofs et al., 2020; Vaicenavicius et al., 2019; Gupta et al., 2021). Section 5 discusses these issues and our approaches to mitigate them. ",
+        "bbox": [
+            174,
+            391,
+            825,
+            542
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Alternatives to ECE include likelihood measures, Brier score (Brier, 1950), Bayesian methods (Gelman et al., 2013), and conformal prediction (Shafer & Vovk, 2008). Further, model calibration can be represented visually with reliability diagrams (DeGroot & Fienberg, 1983). Figure 8 and Appendix F provide likelihoods, Brier scores, and reliability diagrams for our main analyses. ",
+        "bbox": [
+            174,
+            549,
+            825,
+            604
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Empirical studies of model calibration. There have been many recent empirical studies on the robustness (accuracy under distribution shift) of image classifiers (Geirhos et al., 2019; Taori et al., 2020; Djolonga et al., 2020; Hendrycks et al., 2020a). Several works have also studied calibration. Most notable is Guo et al. (2017), who found that “modern neural networks, unlike those from a decade ago, are poorly calibrated”, that larger networks tend to be calibrated worse, and that “miscalibration worsen[s] even as classification error is reduced.” Other works have corroborated some of these findings (e.g., Thulasidasan et al. 2019; Wen et al. 2021). This line of work suggests a trend that larger models are worse calibrated, which would have major implications for research toward bigger models and datasets. We show that for more recent models, this trend is negligible in-distribution and in fact reverses under distribution shift. ",
+        "bbox": [
+            173,
+            611,
+            825,
+            750
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Ovadia et al. (2019) empirically study calibration under distribution shift and provide a large comparison of methods for improving calibration. They report that both accuracy and calibration deteriorate with distribution shift. While we observe the same trend, we find that the calibration of some recent model families decays so slowly under distribution shift that the decay in accuracy is likely more relevant in practice (Section 4.3). ",
+        "bbox": [
+            174,
+            756,
+            825,
+            825
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Ovadia et al. also find that, across methods for improving calibration, improvements on in-distribution data do not necessarily translate to out-of-distribution data. This finding may suggest that there is little correlation between in-distribution and out-of-distribution calibration in general. However, our results show that, across model architectures, the models with the best in-distribution calibration are also the best-calibrated on a range of out-of-distribution benchmarks. The important implication of this result is that designing models based on in-distribution performance likely also benefits their out-of-distribution performance. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Improving calibration. Many strategies have been proposed to improve model calibration such as post-hoc rescaling of predictions (Guo et al., 2017), averaging multiple predictions (Lakshminarayanan et al., 2017; Wen et al., 2020), and data augmentation (Thulasidasan et al., 2019; Wen et al., 2021). Here, we focus on the intrinsic calibration properties of state-of-the-art model families, rather than methods to further improve calibration. ",
+        "bbox": [
+            173,
+            152,
+            826,
+            223
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As a baseline on top of a model’s intrinsic calibration properties, we study temperature scaling (Guo et al., 2017). It is effective in improving calibration and so simple that it can be applied in many cases at minimal additional cost, in contrast to many more sophisticated methods. Temperature scaling re-scales a model’s logits by a single parameter, chosen to optimize the model’s likelihood on a held-out portion of the training data. This temperature factor changes the model’s confidence, i.e., whether the model predictions are on average too certain (overconfident), optimally confident, or too uncertain (underconfident). The classification accuracy of the model is not affected by temperature scaling. A large fraction of model miscalibration is typically due to average over- or underconfidence, e.g. due to suboptimal training duration (Guo et al., 2017). By normalizing a model’s confidence, temperature scaling not only improves calibration, but also removes a primary confounder that can hide trends in calibration between models (see Section 4.2 and Appendix D). Therefore, we study both unscaled and temperature-scaled predictions in the paper. ",
+        "bbox": [
+            173,
+            228,
+            826,
+            395
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Definitions and Notation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            414,
+            410,
+            431
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider the multi-class classification problem, as analyzed by Bröcker (2009), where we observe a variable $X$ and predict a categorical variable $Y \\in \\{ 1 , 2 , \\dots , k \\}$ . We model our predictor $f$ as a function that maps every input instance $X$ to a categorical distribution over $k$ labels, represented using a vector $f ( X )$ belonging to the $\\left( k - 1 \\right)$ -dimensional simplex $\\Delta = \\{ p \\in [ 0 , 1 ] ^ { k } \\mid \\sum _ { y = 1 } ^ { k } p _ { y } = 1 \\}$ . ",
+        "bbox": [
+            174,
+            445,
+            825,
+            506
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, a model $f$ is well-calibrated if its output truthfully quantifies the predictive uncertainty. For example, if we take all data points $x$ for which the model predicts $[ f ( x ) ] _ { y } \\stackrel { - } { = } 0 . 3$ , we expect $3 0 \\%$ of them to indeed take on the label $y$ . Formally, the model $f$ is said to be calibrated if (Bröcker, 2009) ",
+        "bbox": [
+            174,
+            512,
+            825,
+            555
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7a626242e95680fa350970d38d27b9bb4b2159647c61944902945b73243be4e6.jpg",
+        "text": "$$\n\\forall p \\in \\Delta \\colon P ( Y = y \\mid f ( X ) = p ) = p _ { y } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            561,
+            627,
+            579
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We will focus on a slightly weaker, but more practical condition, called top-label or argmax calibration (Kumar et al., 2019; Guo et al., 2017). This requires that the above holds only for the most likely label, i.e., $\\forall p ^ { * } \\in [ 0 , 1 ]$ ",
+        "bbox": [
+            174,
+            585,
+            825,
+            627
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b8aa22ad0fb2784bab2f90419687a7bede483e8fb5ce64370c7a4da2f961e2a7.jpg",
+        "text": "$$\nP ( Y \\in \\arg \\operatorname* { m a x } { p } \\mid \\operatorname* { m a x } { f ( X ) } = p ^ { * } ) = p ^ { * } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            626,
+            643,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the max and arg max act coordinate-wise. ",
+        "bbox": [
+            173,
+            647,
+            496,
+            661
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The most common measure of the degree of miscalibration is the Expected Calibration Error $( E C E )$ , which computes the expected disagreement between the two sides of eq. (2) ",
+        "bbox": [
+            173,
+            667,
+            825,
+            696
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d3d3a713197fb15d86d3795188604fd2eb5f4928fc23ce7017407ce043363310.jpg",
+        "text": "$$\n\\mathbb { E } \\big [ | p ^ { * } - E [ Y \\in \\arg \\operatorname* { m a x } f ( X ) \\mid \\operatorname* { m a x } f ( X ) = p ^ { * } | \\big ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            702,
+            671,
+            722
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unfortunately, eq. (3) cannot be estimated without quantization as it conditions on a null event. Hence, one typically first buckets the predictions into $m$ bins $B _ { 1 } , \\ldots , B _ { m }$ based on their top predicted probability, and then takes the expectation over these buckets. Namely, if we are given a set of $n$ i.i.d. samples $( x _ { 1 } , y _ { 1 } ) , \\dotsc , ( x _ { n } , y _ { n } )$ distributed as $P ( X , Y )$ , then we assign each $\\bar { \\boldsymbol j } \\in \\{ 1 , \\dots , n \\}$ $B _ { i }$ n max  and th $f ( x _ { j } )$ . Tracy $B _ { i }$ nfidenc, where $( B _ { i } ) =$ $\\begin{array} { r } { \\frac { 1 } { | B _ { i } | } \\sum _ { j \\in B _ { i } } \\operatorname* { m a x } f ( x _ { j } ) } \\end{array}$ $\\begin{array} { r } { \\mathbf { \\Gamma } ^ { \\prime } ( B _ { i } ) = \\frac { 1 } { | B _ { i } | } \\sum _ { j \\in B _ { i } } \\mathbb { [ } y _ { j } \\in \\arg \\operatorname* { m a x } f ( x _ { j } ) \\mathbb { I } } \\end{array}$ $[ [ \\cdot ] ]$ Iverson bracket. Finally, we construct an estimator by taking the expectation over the bins ",
+        "bbox": [
+            173,
+            727,
+            825,
+            829
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b22e59c3064647461f64704f7e2b153bea916a4cbdeaff35e6966f66685c1fb9.jpg",
+        "text": "$$\n{ \\widehat { \\mathrm { E C E } } } = \\sum _ { i = 1 } ^ { m } { \\frac { | B _ { i } | } { n } } \\left| { \\mathrm { a c c u r a c y } } ( B _ { i } ) - { \\mathrm { c o n f i d e n c e } } ( B _ { i } ) \\right| .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            835,
+            669,
+            877
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In Section 5 we discuss the statistical properties of this estimator, possible pitfalls, and several mitigation strategies. ",
+        "bbox": [
+            173,
+            882,
+            823,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/d3873263ce65e780310aec7852fb074b4296d9234b239bed7aff776fb8b4ae9f.jpg",
+        "image_caption": [
+            "Figure 1: Some modern neural network families are both highly accurate and well-calibrated. Left: Expected calibration error (ECE) vs. classification error on IMAGENET for state-of-the-art image classification models. Marker size indicates relative model size within its family. Points labeled “Guo et al.” are the values reported for DenseNet-161 and ResNet-152 in Guo et al. (2017). Right: Confidence distribution (top row) and reliability diagrams (bottom row) for some of the models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            88,
+            820,
+            227
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Empirical Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            334,
+            385,
+            352
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experimental Setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            367,
+            352,
+            382
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Model families. In this study, we consider a range of recent and some historic state-of-the-art image classification models. Our selection of models covers convolutional and non-convolutional architectures, as well as supervised, weakly supervised, unsupervised and zero-shot training. We follow the original publications in naming the model variants within each family (e.g. different model sizes). See Appendix A.1 for a detailed description of all used models. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            463
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. MLP-Mixer (Tolstikhin et al., 2021) is based exclusively on multi-layer perceptrons (MLPs) and is pre-trained on large supervised datasets.   \n2. ViT (Dosovitskiy et al., 2021) processes images with a transformer architecture originally designed for language (Vaswani et al., 2017) and is also pre-trained on large supervised datasets.   \n3. BiT (Kolesnikov et al., 2020) is a ResNet-based architecture (He et al., 2016). It is also pre-trained on large supervised datasets.   \n4. ResNext-WSL (Mahajan et al., 2018) is based on the ResNeXt architecture and trained with weak supervision from billions of hashtags on social media images.   \n5. SimCLR (Chen et al., 2020) is a ResNet, pretrained with an unsupervised contrastive loss.   \n6. CLIP (Radford et al., 2021) is pretrained on raw text and imagery using a contrastive loss.   \n7. AlexNet (Krizhevsky et al., 2012; Krizhevsky, 2014) was the first convolutional neural network to win the ImageNet challenge. ",
+        "bbox": [
+            192,
+            469,
+            826,
+            636
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "All models are either trained or fine-tuned on the IMAGENET training set, except for CLIP, which makes zero-shot predictions using IMAGENET class names as queries. ",
+        "bbox": [
+            174,
+            642,
+            823,
+            670
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We evaluate accuracy and calibration on the IMAGENET validation set and the following out-of-distribution benchmarks using the Robustness Metrics library (Djolonga et al., 2020): ",
+        "bbox": [
+            173,
+            676,
+            823,
+            705
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. IMAGENETV2 (Recht et al., 2019) is a new IMAGENET test set collected by closely following the original IMAGENET labeling protocol.   \n2. IMAGENET-C (Hendrycks & Dietterich, 2019) consists of the images from IMAGENET, modified with synthetic perturbations such as blur, pixelation, and compression artifacts at a range of severities.   \n3. IMAGENET-R (Hendrycks et al., 2020a) contains artificial renditions of IMAGENET classes such as art, cartoons, drawings, sculptures, and others.   \n4. IMAGENET-A (Hendrycks et al., 2021) contains images that are classified as belonging to IMAGENET classes by humans, but adversarially selected to be hard to classify for a ResNet50 trained on IMAGENET. ",
+        "bbox": [
+            192,
+            710,
+            826,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For the post-hoc recalibration of models, we reserve $20 \\%$ of the IMAGENET validation set (randomly sampled) for fitting the temperature scaling parameter. All reported metrics are computed on the remaining $80 \\%$ of the data. For evaluations on IMAGENET-C, we also exclude the $20 \\%$ of images that are based on the IMAGENET images used for temperature scaling. ",
+        "bbox": [
+            176,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Calibration metric. Throughout the paper, we estimate ECE using equal-mass binning and 100 bins. Appendix E shows that our results hold for other ECE variants and are consistent with the Brier score and model likelihood. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 In-Distribution Calibration ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            151,
+            401,
+            165
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We begin by considering ECE on clean IMAGENET images (referred to as in-distribution). Figure 1 shows in-distribution ECE and reliability diagrams before any recalibration of the predicted probabilities. We find that several recent model families (MLP-Mixer, ViT, and BiT) are both highly accurate and well-calibrated compared to prior models, such as AlexNet or the models studied by Guo et al. (2017). This suggests that there may be no continuing trend for highly accurate modern neural networks to be poorly calibrated, as suggested previously (Guo et al., 2017; Lakshminarayanan et al., 2017; Malinin & Gales, 2018; Thulasidasan et al., 2019; Hendrycks et al., 2020b; Ovadia et al., 2019; Wenzel et al., 2020; Havasi et al., 2021; Rahaman & Thiery, 2020; Leathart & Polaczuk, 2020). In addition, we find that a recent zero-shot model, CLIP, is well-calibrated given its accuracy. ",
+        "bbox": [
+            173,
+            176,
+            825,
+            301
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Temperature scaling reveals consistent properties of model families. The poor calibration of past models can often be remedied by post-hoc recalibration such as temperature scaling (Guo et al., 2017), which raises the question whether a difference between models remains after recalibration. We find that the most recent architectures are better calibrated than past models even after temperature scaling (Figure 2, right). ",
+        "bbox": [
+            173,
+            308,
+            825,
+            377
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "More generally, temperature scaling reveals consistent trends in the calibration properties between families that are obscured in the unscaled data by simple over- or underconfidence miscalibration. Before temperature scaling (Figure 2, left), several families overlap in their accuracy/calibration properties (MLP-Mixer, ViT, BiT). After temperature scaling (Figure 2, right), a clearer separation of families and consistent trends between accuracy and calibration within each family become apparent. Notably, temperature scaling reconciles our results for BiT (a ResNet architecture) with the results reported by Guo et al. for ResNets trained on IMAGENET. Furthermore, models pretrained without addi",
+        "bbox": [
+            174,
+            385,
+            485,
+            589
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/7be6364f70c451e752fc05f4f0702ef975baa8db00ee92ad42e0203616c5f878.jpg",
+        "image_caption": [
+            "Figure 2: Temperature scaling reveals consistent properties of model families. Left: ECE vs. classification error as in Figure 1. Right: ECE after applying temperature scaling. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            387,
+            820,
+            512
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "tional labels (SimCLR) or with noisy labels (ResNeXt-WSL) tend to be calibrated worse for a given accuracy than ResNets trained with supervision (BiT and the models studied by Guo et al.). Finally, non-convolutional model families like MLP-Mixer and ViT can perform just as well, if not better, than convolutional ones. ",
+        "bbox": [
+            174,
+            590,
+            828,
+            645
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Differences between families are not explained by model size or pretraining amount. We next attempt to disentangle how the differences between model families affect their calibration properties. We focus on model size and amount of pretraining, both important trends in state of-the-art models. ",
+        "bbox": [
+            176,
+            652,
+            821,
+            694
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first consider model size. Prior work has suggested that larger neural networks are worse calibrated (Guo et al., 2017). We also find that within most families, larger members tend to have higher calibration error (Figure 2, right). However, at the same time, larger models have consistently lower classification error. This means that each model family occupies a different Pareto set in the tradeoff between accuracy and calibration. For example, our results suggest that, at any given accuracy, ViT models are better calibrated than BiT models. Changing the size of a BiT model cannot move it into the Pareto set of ViT models. Model size can therefore not fully explain the intrinsic calibration differences between these model families.2 ",
+        "bbox": [
+            174,
+            700,
+            825,
+            811
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We next consider model pretraining. Many current state-of-the-art image models use transfer learning, in which a model is pre-trained on a large dataset and then fine-tuned to the task of interest (Kolesnikov et al., 2020; Chen et al., 2020; Xie et al., 2020). With transfer learning, large data sources can be exploited to train the model, even if little data are available for the final task. To test how the amount of pretraining affects calibration, we compare BiT models pretrained on IMAGENET (1.3M images), IMAGENET-21K (12.8M images), or JFT-300 (300M images; Sun et al. 2017). ",
+        "bbox": [
+            176,
+            818,
+            823,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            826,
+            133
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "More pretraining data consistently increases accuracy, especially for larger models. It has no consistent effect on calibration (Figure 3). In particular, after temperature scaling, ECE is essentially unchanged across this 300-fold increase in pretraining dataset size (e.g. for BiTR50x1 pretrained on IMAGENET, IMAGENET21K and JFT-300, the ECEs are 0.0185, 0.0182, 0.0185, respectively; for BiT-R101x3, they are 0.0272, 0.0311, 0.0236; Figure 3, bottom). Therefore, regardless of the pretraining dataset, BiT always remains Pareto-dominant over SimCLR and Pareto-dominated by ViT and MLPMixer in our experiments. ",
+        "bbox": [
+            174,
+            140,
+            485,
+            332
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The BiT models compared in Figure 3 differ in both the amount of pretraining data and the duration of pretraining (see Kolesnikov et al. (2020) for details). To further disentangle these variables, we trained BiT models on varying numbers of pretraining examples while holding the number of training steps constant, and vice versa. We find that pretraining dataset size has no significant effect on calibration, while pretraining duration only shifts the model within its accuracy/calibration Pareto set (longer-trained models are more accurate and worse calibrated; Figure 10). These results suggest that pretraining alone cannot explain the differences between model families that we observe. ",
+        "bbox": [
+            174,
+            339,
+            483,
+            545
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/e0612eaa30c873581b31c32f299479b5cd52f7e19aadbbb95b216b9d1360de43.jpg",
+        "image_caption": [
+            "Figure 3: Family differences are not fully explained by the amount of pretraining. Each column shows ECE vs. classification error on ImageNet for BiT models pre-trained with a different dataset: IMAGENET (1.3M images), IMAGENET-21K (12.8M images), or JFT-300 (300M images). The values for other models are provided for reference in light shading (same values as in Figure 2). Note how all BiT models remain in the same relative location between ViT and SimCLR across a 300-fold difference in pretraining data size. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            145,
+            813,
+            356
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In summary, our results show that some modern neural network families combine high accuracy and state-of-the-art calibration on in-distribution data, both before and after post-hoc recalibration by temperature scaling. In Figure 8 and Appendices E and F, we show that these results generally hold for other measures of model calibration (other ECE variants, Brier score, and model likelihood). Our experiments further suggest that model size and pretraining amount do not fully explain the intrinsic calibration differences between model families. Given that the best-calibrated families (MLP-Mixer and ViT) are non-convolutional, we speculate that model architecture, and in particular its spatial inductive bias, play an important role. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            664
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Accuracy and Calibration Under Distribution Shift ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            702,
+            568,
+            718
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For safety-critical applications, the model should produce reasonable uncertainty estimates not just in-distribution, but also under distribution shifts that were not anticipated at training time. We first assess out-of-distribution calibration on the IMAGENET-C dataset, which consists of images that have been synthetically corrupted at five different severities. As expected, both classification and calibration error generally increase with distribution shift (Figure 4; Ovadia et al. 2019; Hendrycks & Dietterich 2019). Interestingly, this decay in calibration performance is slower for MLP-Mixer and ViT than for the other model families, both before and after temperature scaling. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            835
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Regarding the effect of model size on calibration, we observed some trend towards worse calibration of larger models on in-distribution data. However, the trend is reversed for most model families as we move out of distribution, especially after accounting for confidence bias by temperature scaling (note positive slope of the gray lines at high corruption severities in Figure 4, bottom row). In other words, the calibration of larger models is more robust to distribution shift (Figure 5). ",
+        "bbox": [
+            174,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/1d3f1e8b7d26bdfb208d0c65d3ef6e1916c839d954b1c192e7a7255065ff598c.jpg",
+        "image_caption": [
+            "Figure 4: Calibration and accuracy on IMAGENET-C before (top) and after (bottom) temperature scaling on IMAGENET. Severity 0 refers to the clean IMAGENET test set; marker size indicates relative model size within its family (see Table 1 for model details). The calibration of some recent model families, e.g. MLP-Mixer and ViT, is more robust to distribution shift than past models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            87,
+            820,
+            318
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We next consider to what degree the insights from in-distribution and IMAGENET-C calibration transfer to natural out-of-distribution data. Previous work on IMAGENET-C suggests that, when comparing recalibration methods, better in-distribution calibration and accuracy do not usually predict better calibration under distribution shift (Ovadia et al., 2019). Here, comparing model families, we find that the performance on several natural out-of-distribution datasets is largely consistent with that on IMAGENET (Figure 6). In particular, models that are Pareto-optimal (i.e. no other model is both more accurate and better calibrated) on IMAGENET remain Pareto-optimal on the OOD datasets. Further, we observe a strong correlation between accuracy and calibration on the OOD datasets. This relationship is consistent across models within a family and across datasets, over a wide range of accuracies (Figure 11). ",
+        "bbox": [
+            173,
+            406,
+            825,
+            545
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "These results suggest that larger and more accurate models, and in particular MLP-Mixer and ViT, can maintain their good in-distribution calibration even under severe distribution shifts. Based on the observed relationship between calibration and accuracy, we can reasonably hope that good calibration on in-distribution data (and anticipated distribution shifts) generally translates into good calibration on unanticipated outof-distribution data, similar to what has been observed for accuracy (Djolonga et al., 2020). ",
+        "bbox": [
+            174,
+            551,
+            486,
+            703
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 Relating Accuracy and Calibration Within Model Families ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            727,
+            450,
+            756
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our data suggest that most model families lie on different Pareto sets in the accuracy/calibration space, which establishes a clear preference between families. We next consider how to compare individual models within a family (or more specifically, within a Pareto set), where one model is more accurate but worse calibrated, and the other is less accurate but better calibrated. Which model should a practitioner choose for a safety-critical application? ",
+        "bbox": [
+            174,
+            770,
+            485,
+            909
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/d76d583138787f2a8a5c51e8aeea92feb7a3d544aed6c3391b3fdd4c20582f6a.jpg",
+        "image_caption": [
+            "Figure 5: Classification error and ECE for the top three families on IMAGENET-C, relative to the largest model variant in each family. As distribution shift increases, both errors tend to increase more slowly for larger models. Also note that changes in ECE are much smaller than changes in classification error. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            501,
+            558,
+            821,
+            765
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/6820bf8fd2a4bab04d2ea4c0b78c65f0ad2da759aced17e74a5948293ffcc419.jpg",
+        "image_caption": [
+            "Figure 6: Calibration and accuracy before (top row) and after (bottom row) temperature scaling on out-of-distribution benchmarks. Marker size indicates relative model size within its family. IMAGENET-R and IMAGENET-A use a reduced subset of 200 classes; we follow the literature and select the subset of the model logits for these classes before evaluation. Out-of-distribution calibration tends to correlate with in-distribution calibration (Figure 1) and out-of-distribution accuracy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            820,
+            327
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The answer depends on the cost structure of the specific application (Hernández-Orallo et al., 2012). As an example, consider the scenario of selective prediction, which is common in medical diagnosis. In this task, one can choose to ignore the model prediction (“abstain”) at a fixed cost if the prediction confidence is low, rather than risking a (more costly) prediction error. ",
+        "bbox": [
+            174,
+            425,
+            485,
+            536
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 7 compares the expected cost for two BiT variants, one with better classification error $( \\mathrm { R } 1 5 2 \\mathrm { x } 4 $ , by 0.08), and one with better ECE (R50x1, by 0.009). For abstention rates up to $70 \\%$ (which covers most practical scenarios with abstention rates low enough for the model to be useful), the model with better accuracy has a lower overall cost than the model with better ECE. The same is true for all other model families we study (Appendix B.3). For these families and this cost scenario, a practitioner should therefore always choose the most accu",
+        "bbox": [
+            174,
+            541,
+            483,
+            707
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/cfa32322a95ce2977cd5a22d547acc5ef1b9158786cdcf462dfa3c3324fb13b7.jpg",
+        "image_caption": [
+            "Figure 7: Relative cost of BiT-R $1 5 2 \\mathrm { x } 4$ and BiT$\\mathrm { R } 5 0 \\mathrm { x } 1$ models in a selective prediction scenario, computed as a combination of the misclassification and abstention costs at a given cost ratio $\\mathbf { \\dot { x } }$ -axis) and abstention rate (y-axis). Blue indicates regions where the higher-accuracy model $( \\mathrm { R } 1 5 2 \\mathrm { x } 4 )$ achieves a lower cost than the bettercalibrated model (R50x1). The accuracy advantage outweighs the calibration advantage for practical rejection rates, across all tested abstention costs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            508,
+            429,
+            813,
+            547
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "rate available model regardless of differences in calibration. Ultimately, real-world cost structures are complex and may yield different results; Figure 7 presents one common scenario with downstream ramifications for the importance of the calibration differences compared to accuracy. ",
+        "bbox": [
+            176,
+            708,
+            825,
+            750
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Pitfalls and Limitations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            773,
+            401,
+            790
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For this study, we approached calibration with a simple, practical question: Given two models, one more accurate and the other better calibrated, which should a practitioner choose? While working towards answering this question, we encountered several pitfalls that complicate the interpretation of calibration results. ",
+        "bbox": [
+            174,
+            808,
+            825,
+            863
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Measuring calibration is challenging, and while the quantity we want to estimate is well specified, the estimator itself can be biased. There are two sources of bias: (i) from estimating ECE by binning, and (ii) from the finite sample size used to estimate the per-bin statistics. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/9db148e6dc3909c486ef77ec646f6fad8a42681b75c2ad3563bc5b379711c097.jpg",
+        "image_caption": [
+            "Figure 8: Alternative calibration metrics: negative log-likelihood (NLL) and Brier score. For comparison, the first row shows ECE as in Figure 6. Since NLL, Brier score, and classification error are all highly correlated, we also provide the residuals of NLL and Brier score after regressing out classification error (third and fifth row). Specifically, we first fit a linear regression $y _ { i } = \\beta _ { 0 } + \\beta _ { 1 } x _ { i }$ , where $x _ { i }$ is the classification error and $y _ { i }$ is the calibration measure of model $i$ . We then report the residual $y _ { i } - \\left( \\beta _ { 0 } + \\beta _ { 1 } x _ { i } \\right)$ on the $y$ -axis of the plots in the third and fifth row. The residuals show which models have better (or worse) NLL and Brier score than what can be expected from their accuracy alone. The relationships between model families are largely similar across all calibration metrics. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            87,
+            818,
+            609
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The first of these biases is always negative (Kumar et al., 2019), while the second one is always positive. Thus, the estimator can both under- and over-estimate the true value, and the magnitude of the bias can depend on multiple factors. In practice, this means that the ranking of models depends on which ECE variant is chosen to estimate calibration (Nixon et al., 2019). As we show below, this is especially problematic for the positive bias, because this bias depends on the accuracy of the model. It is therefore possible to arrive at opposite conclusions about the relationship between accuracy and calibration, depending on the chosen bin size (Figure 9), especially when comparing models with widely varying accuracies. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            909
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, a larger number of bins implies fewer points per bin and thus higher variance of the estimate of the model accuracy in each bin, which adds positive bias to the estimate of ECE. More formally, to estimate accuracy $( B _ { i } )$ precisely, we need a number of samples inversely proportional to the standard deviation $\\sqrt { p _ { i } ( 1 - p _ { i } ) } / | B _ { i } |$ , where $p _ { i }$ is the expected accuracy in $B _ { i }$ . This indicates that the bias would be smaller for models with extreme average accuracies (i.e. close to 0 or 1) and larger for models with an accuracy close to 0.5. A detailed analysis reveals additional effects that further reduce the bias for higher-accuracy models (Appendix C). In particular, if we estimate $( \\mathbb { E } [ \\mathrm { a c c u r a c y } ( B _ { i } ) ] - \\mathbb { E } [ \\mathrm { \\bar { c } o n f i d e n c e } ( B _ { i } ) ] ) ^ { 2 }$ for any bin $i$ with $n _ { i }$ samples (using the sample means of the confidences and the accuracies), the bias can be shown to be equal to (conditioning on $X \\in B _ { i }$ omitted for brevity) ",
+        "bbox": [
+            174,
+            90,
+            485,
+            369
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/a4030819ad6555c65f3667055cf16acf6245c9c6d1ca04a6cb15713a840d04f0.jpg",
+        "image_caption": [
+            "Figure 9: The effect of binning-induced bias in ECE depends on accuracy. Each dot represents a BiT ResNet model. Plotted models differ in model size, pretraining dataset size, and pretraining duration. All models are fine-tuned and evaluated on IMAGENET. After temperature scaling, there is a near-linear relationship between ECE and classification error. However, whether this relationship is positive or negative depends on the number of bins used for estimating ECE. This effect is explained by an accuracy-dependent bias that increases with the number of bins. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            93,
+            823,
+            188
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bd947aba261595c8374d4f2c5a6680a6c3cccf1b07bd528cfd2b3b368033f71e.jpg",
+        "text": "$$\n\\frac { 1 } { n _ { i } } ( \\mathbb { V } [ A ] + \\mathbb { V } [ C ] - 2 { \\bf C o v } [ C , A ] ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            378,
+            611,
+            411
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "where $A = [ [ Y \\in \\arg \\operatorname* { m a x } { f ( X ) } ] ]$ and $C = \\operatorname* { m a x } f ( X )$ . Hence, from Equation 5 we can conclude J Kthat higher accuracy models have a lower bias not only due to higher accuracy (lower $\\mathbb { V } [ A ] )$ , but also because their outputs correlate more with the correct label (higher covariance). ",
+        "bbox": [
+            174,
+            419,
+            825,
+            462
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In addition to a careful choice of bin size, considering accuracy and calibration jointly mitigates this issue, because the Pareto-optimal models rarely change, even if the ranking based on ECE alone does (Appendix E). In Appendices E and F, we provide the main figures of the paper for other ECE variants (number of bins, binning scheme, normalization metric, top-label, all-label, class-wise). ",
+        "bbox": [
+            174,
+            468,
+            825,
+            523
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Finally, metrics such as Brier score (Brier, 1950) and likelihood provide alternative assessments of model calibration that do not require estimating expected calibration error. We find that the relationships between model families are consistent across ECE, NLL and Brier score (Figure 8). In particular, the same models (specifically the largest MLP-Mixer and ViT variants) remain Paretooptimal with respect to the calibration metric and classification error in most cases. The relationship between models is visualized especially clearly after regressing out from the calibration metrics their correlation with classification error (Figure 8, third and fifth row). ",
+        "bbox": [
+            173,
+            530,
+            825,
+            627
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            650,
+            299,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We performed a large study of the calibration of recent state-of-the-art image models and its relationship with accuracy. We find that modern image models are well calibrated across distribution shifts despite being designed with a focus on accuracy. Our results suggest that there is no general trend for recent or highly accurate neural networks to be poorly calibrated compared to older or less accurate models. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            752
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our experiments suggest that simple dimensions such as model size and pretraining amount do not fully account for the performance differences between families, pointing towards architecture as a major determinant of calibration. Of particular note is the finding that MLP-Mixer and Vision Transformers—two recent architectures that are not based on convolutions—are among the best-calibrated models both in-distribution and out-of-distribution. Self-attention (which Vision Transformers employ heavily) has been shown previously to be beneficial for certain kinds of outof-distribution robustness (Hendrycks et al., 2020a). Our work now hints at calibration benefits of non-convolutional architectures more broadly, for certain kinds of distribution shift. Further work on the influence of architectural inductive biases on calibration and out-of-distribution robustness will be necessary to tell whether these results generalize. If so, they may further hasten the end of the convolutional era in computer vision. ",
+        "bbox": [
+            173,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            553,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We thank Carlos Riquelme and Balaji Lakshminarayanan for valuable comments on the manuscript.   \nThe authors declare no competing interests.   \nReferences   \nBojarski, M., Del Testa, D., Dworakowski, D., Firner, B., Flepp, B., Goyal, P., Jackel, L. D., Monfort, M., Muller, U., Zhang, J., et al. End to end learning for self-driving cars. arXiv: 1604.07316, 2016.   \nBrier, G. W. Verification of forecasts expressed in terms of probability. Monthly weather review, 1950.   \nBröcker, J. Reliability, sufficiency, and the decomposition of proper scores. Journal of the Royal Meteorological Society, 2009.   \nChen, T., Kornblith, S., Norouzi, M., and Hinton, G. E. A simple framework for contrastive learning of visual representations. In International Conference on Machine Learning, 2020.   \nDeGroot, M. H. and Fienberg, S. E. The comparison and evaluation of forecasters. Journal of the Royal Statistical Society, 1983.   \nDeng, J., Dong, W., Socher, R., Li, L.-J., Li, K., and Fei-Fei, L. Imagenet: A large-scale hierarchical image database. In Conference on Computer Vision and Pattern Recognition, 2009.   \nDjolonga, J., Matthias, M., Nado, Z., Nixon, J., Romijnders, R., Tran, D., and Lucic, M. Robustness Metrics, 2020. URL https://github.com/google-research/robustness_metrics.   \nDosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn, D., Zhai, X., Unterthiner, T., Dehghani, M., Minderer, M., Heigold, G., Gelly, S., Uszkoreit, J., and Houlsby, N. An image is worth 16x16 words: Transformers for image recognition at scale. In International Conference on Learning Representations, 2021.   \nEsteva, A., Kuprel, B., Novoa, R. A., Ko, J., Swetter, S. M., Blau, H. M., and Thrun, S. Dermatologistlevel classification of skin cancer with deep neural networks. Nature, 2017.   \nGeirhos, R., Rubisch, P., Michaelis, C., Bethge, M., Wichmann, F. A., and Brendel, W. Imagenettrained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness. In International Conference on Learning Representations, 2019.   \nGelman, A., Carlin, J. B., Stern, H. S., Dunson, D. B., Vehtari, A., and Rubin, D. B. Bayesian data analysis. CRC press, 2013.   \nGneiting, T., Balabdaoui, F., and Raftery, A. E. Probabilistic forecasts, calibration and sharpness. Journal of the Royal Statistical Society, 2007.   \nGuo, C., Pleiss, G., Sun, Y., and Weinberger, K. Q. On calibration of modern neural networks. In International Conference on Machine Learning, 2017.   \nGupta, K., Rahimi, A., Ajanthan, T., Mensink, T., Sminchisescu, C., and Hartley, R. Calibration of neural networks using splines. International Conference on Learning Representations, 2021.   \nHavasi, M., Jenatton, R., Fort, S., Liu, J. Z., Snoek, J., Lakshminarayanan, B., Dai, A. M., and Tran, D. Training independent subnetworks for robust prediction. In International Conference on Learning Representations, 2021.   \nHe, K., Zhang, X., Ren, S., and Sun, J. Identity mappings in deep residual networks. In European Conference on Computer Vision, 2016.   \nHendrycks, D. and Dietterich, T. Benchmarking neural network robustness to common corruptions and perturbations. In International Conference on Learning Representations, 2019.   \nHendrycks, D., Basart, S., Mu, N., Kadavath, S., Wang, F., Dorundo, E., Desai, R., Zhu, T., Parajuli, S., Guo, M., et al. The many faces of robustness: A critical analysis of out-of-distribution generalization. arXiv: 2006.16241, 2020a.   \nHendrycks, D., Mu, N., Cubuk, E. D., Zoph, B., Gilmer, J., and Lakshminarayanan, B. Augmix: A simple data processing method to improve robustness and uncertainty. In International Conference on Learning Representations, 2020b.   \nHendrycks, D., Zhao, K., Basart, S., Steinhardt, J., and Song, D. Natural adversarial examples. In Conference on Computer Vision and Pattern Recognition, 2021.   \nHernández-Orallo, J., Flach, P. A., and Ferri, C. A unified view of performance metrics: translating threshold choice into expected classification loss. Journal of Machine Learning Research, 2012.   \nJiang, X., Osl, M., Kim, J., and Ohno-Machado, L. Calibrating predictive model estimates to support personalized medicine. Journal of the American Medical Informatics Association, 2012.   \nKolesnikov, A., Beyer, L., Zhai, X., Puigcerver, J., Yung, J., Gelly, S., and Houlsby, N. Big transfer (bit): General visual representation learning. In European Conference on Computer Vision, 2020.   \nKompa, B., Snoek, J., and Beam, A. L. Second opinion needed: communicating uncertainty in medical machine learning. NPJ Digital Medicine, 2021.   \nKrizhevsky, A. One weird trick for parallelizing convolutional neural networks. arXiv: 1404.5997, 2014.   \nKrizhevsky, A., Sutskever, I., and Hinton, G. E. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems, 2012.   \nKumar, A., Liang, P. S., and Ma, T. Verified uncertainty calibration. In Advances in Neural Information Processing Systems, 2019.   \nLakshminarayanan, B., Pritzel, A., and Blundell, C. Simple and scalable predictive uncertainty estimation using deep ensembles. In Advances in Neural Information Processing Systems, 2017.   \nLeathart, T. and Polaczuk, M. Temporal probability calibration. arXiv: 2002.02644, 2020.   \nMahajan, D., Girshick, R. B., Ramanathan, V., He, K., Paluri, M., Li, Y., Bharambe, A., and van der Maaten, L. Exploring the limits of weakly supervised pretraining. In European Conference on Computer Vision, 2018.   \nMalinin, A. and Gales, M. J. F. Predictive uncertainty estimation via prior networks. In Advances in Neural Information Processing Systems, 2018.   \nMüller, R., Kornblith, S., and Hinton, G. E. When does label smoothing help? In Advances in Neural Information Processing Systems, 2019.   \nMustafa, B., Loh, A., Freyberg, J., MacWilliams, P., Wilson, M., McKinney, S. M., Sieniek, M., Winkens, J., Liu, Y., Bui, P., Prabhakara, S., Telang, U., Karthikesalingam, A., Houlsby, N., and Natarajan, V. Supervised transfer learning at scale for medical imaging. arXiv: 2101.05913, 2021.   \nNaeini, M. P., Cooper, G., and Hauskrecht, M. Obtaining well calibrated probabilities using bayesian binning. In AAAI Conference on Artificial Intelligence, 2015.   \nNixon, J., Dusenberry, M. W., Zhang, L., Jerfel, G., and Tran, D. Measuring calibration in deep learning. In IEEE Conference on Computer Vision and Pattern Recognition Workshops, 2019.   \nOvadia, Y., Fertig, E., Lakshminarayanan, B., Nowozin, S., Sculley, D., Dillon, J. V., Ren, J., Nado, Z., and Snoek, J. Can you trust your model’s uncertainty? evaluating predictive uncertainty under dataset shift. In Advances in Neural Information Processing Systems, 2019.   \nRadford, A., Kim, J. W., Hallacy, C., Ramesh, A., Goh, G., Agarwal, S., Sastry, G., Askell, A., Mishkin, P., Clark, J., et al. Learning transferable visual models from natural language supervision. Technical report, OpenAI, 2021.   \nRahaman, R. and Thiery, A. H. Uncertainty quantification and deep ensembles. arXiv: 2007.08792, 2020. ",
+        "bbox": [
+            174,
+            119,
+            825,
+            148
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            165,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            59,
+            828,
+            905
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Recht, B., Roelofs, R., Schmidt, L., and Shankar, V. Do imagenet classifiers generalize to imagenet? In International Conference on Machine Learning, 2019.   \nRoelofs, R., Cain, N., Shlens, J., and Mozer, M. C. Mitigating bias in calibration error estimation. arXiv: 2012.08668, 2020.   \nShafer, G. and Vovk, V. A tutorial on conformal prediction. Journal of Machine Learning Research, 2008.   \nSønderby, C. K., Espeholt, L., Heek, J., Dehghani, M., Oliver, A., Salimans, T., Agrawal, S., Hickey, J., and Kalchbrenner, N. Metnet: A neural weather model for precipitation forecasting. arXiv: 2003.12140, 2020.   \nSun, C., Shrivastava, A., Singh, S., and Gupta, A. Revisiting unreasonable effectiveness of data in deep learning era. In International Conference on Computer Vision, 2017.   \nSzegedy, C., Vanhoucke, V., Ioffe, S., Shlens, J., and Wojna, Z. Rethinking the inception architecture for computer vision. In Conference on Computer Vision and Pattern Recognition, 2016.   \nTaori, R., Dave, A., Shankar, V., Carlini, N., Recht, B., and Schmidt, L. Measuring robustness to natural distribution shifts in image classification. Advances in Neural Information Processing Systems, 2020.   \nThulasidasan, S., Chennupati, G., Bilmes, J. A., Bhattacharya, T., and Michalak, S. On mixup training: Improved calibration and predictive uncertainty for deep neural networks. In Advances in Neural Information Processing Systems, 2019.   \nTolstikhin, I., Houlsby, N., Kolesnikov, A., Beyer, L., Zhai, X., Unterthiner, T., Yung, J., Steiner, A., Keysers, D., Uszkoreit, J., Lucic, M., and Dosovitskiy, A. MLP-Mixer: An all-MLP architecture for vision. arXiv: 2105.01601, 2021.   \nVaicenavicius, J., Widmann, D., Andersson, C. R., Lindsten, F., Roll, J., and Schön, T. B. Evaluating model calibration in classification. In International Conference on Artificial Intelligence and Statistics, 2019.   \nVaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, L., and Polosukhin, I. Attention is all you need. In Advances in Neural Information Processing Systems, 2017.   \nWen, Y., Tran, D., and Ba, J. Batchensemble: an alternative approach to efficient ensemble and lifelong learning. In Advances in Neural Information Processing Systems, 2020.   \nWen, Y., Jerfel, G., Muller, R., Dusenberry, M. W., Snoek, J., Lakshminarayanan, B., and Tran, D. Combining ensembles and data augmentation can harm your calibration. In International Conference on Learning Representations, 2021.   \nWenzel, F., Snoek, J., Tran, D., and Jenatton, R. Hyperparameter ensembles for robustness and uncertainty quantification. In Advances in Neural Information Processing Systems, 2020.   \nXie, Q., Luong, M.-T., Hovy, E., and Le, Q. V. Self-training with noisy student improves imagenet classification. In Conference on Computer Vision and Pattern Recognition, 2020. ",
+        "bbox": [
+            169,
+            90,
+            828,
+            748
+        ],
+        "page_idx": 12
+    }
+]

parse/train/S1xBioR5KX/S1xBioR5KX.md

@@ -0,0 +1,400 @@
+# PARAMETER EFFICIENT TRAINING OF DEEP CONVOLUTIONAL NEURAL NETWORKS BY DYNAMIC SPARSE REPARAMETERIZATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Modern deep neural networks are highly overparameterized, and often of huge sizes. A number of post-training model compression techniques, such as distillation, pruning and quantization, can reduce the size of network parameters by a substantial fraction with little loss in performance. However, training a small network of the post-compression size de novo typically fails to reach the same level of accuracy achieved by compression of a large network, leading to a widely-held belief that gross overparameterization is essential to effective learning. In this work, we argue that this is not necessarily true. We describe a dynamic sparse reparameterization technique that closed the performance gap between a model compressed through iterative pruning and a model of the post-compression size trained de novo. We applied our method to training deep residual networks and showed that it outperformed existing reparameterization techniques, yielding the best accuracy for a given parameter budget for training. Compared to existing dynamic reparameterization methods that reallocate non-zero parameters during training, our approach achieved better performance at lower computational cost. Our method is not only of practical value for training under stringent memory constraints, but also potentially informative to theoretical understanding of generalization properties of overparameterized deep neural networks.
+
+# 1 INTRODUCTION
+
+Deep neural network’s success is due in no small part to two of its surprising properties that starkly defy conventional wisdom. First, training of modern deep neural networks is a high-dimensional non-convex optimization problem, a kind prohibitively difficult in general from an optimization theoretic viewpoint. Yet first-order gradient-based methods, stochastic gradient descent (SGD) and its variants, prove to be very effective; training seldom gets trapped in bad local minima. Second, overparameterization (i.e. having more model parameters than training data examples) does not undermine generalization; highly overparameterized models in practice seldom overfit, a phenomenon at odds with traditional principles of statistical learning theory.
+
+Simply put, huge models are not hard to train, and trained huge models are not bad ones.
+
+Emerging evidence has attributed these effects to the geometry of high-dimensional loss landscapes of overparameterized deep neural networks (Dauphin et al., 2014; Choromanska et al., 2014; Goodfellow et al., 2014; Im et al., 2016; Wu et al., 2017; Liao & Poggio, 2017; Cooper, 2018; Novak et al., 2018), and to the implicit regularization properties of SGD (Brutzkus et al., 2017; Zhang et al., 2018a; Poggio et al., 2017), though a thorough theoretical understanding is not yet complete. On the other hand, practitioners, blessed in this reality, do not seem to shy away from building gigantic models. Models with parameters in the tens and hundreds of millions are common in practice, with the current record holder having a parameter count in the range of a hundred billion (Shazeer et al., 2017).
+
+However, huge models are computationally expensive, both spatially (in terms of memory requirements) and temporally (in terms of number of operations), at both training time and inference time. Thus, scalable methods for controlling the computational complexity of deep neural networks are key to making them more useful in practice.
+
+To achieve efficient inference, a number of well-established model compression techniques are highly effective in reducing the post-training model size with little degradation in performance. These include distillation (e.g. Bucilua et al. (2006); Hinton et al. (2015)), quantization (e.g. Hubara et al. (2016); McDonnell (2018)), low-rank decomposition (e.g. Denil et al. (2013); Jaderberg et al. (2014)), and pruning (e.g. Han et al. (2015); Zhang et al. (2018b)), to name a few.
+
+Despite their success, post-training compression methods require the full overparameterized model to be trained in the first place. Training remains expensive. In order to make training more efficient, significant efforts have been invested into numerical innovations for training at limited precision (e.g. Courbariaux et al. (2016); Koster et al. (2017)). In contrast, however, little progress has been made in ¨ effective training at significantly reduced number of parameters.
+
+One obvious alternative toward this goal is to seek novel network architectures, ones that are more parameter efficient 1. In fact, recent architectural innovations in deep convolutional neural networks (CNNs) not only achieved better generalization performance, but parameter efficiency as well (see Section 5).
+
+Instead of inventing new networks, an alternative approach is to achieve higher parameter efficiency directly by reparameterizing an existing model architecture. In general, any differentiable reparameterization can be used to augment training of a given model. Let an original network (or a layer therein) be denoted by $\pmb { y } = \bar { f } ( \pmb { x } ; \pmb { \theta } )$ , parameterized by $\theta \in \Theta$ . Reparameterize it by $\phi \in \Phi$ through $\pmb \theta = g ( \phi ; \psi )$ , where $g$ is differentiable w.r.t. $\phi$ but not necessarily w.r.t. $\psi$ . Denote the reparameterized network by $f _ { \psi }$ , considering $\psi$ as metaparameters 2:
+
+$$
+{ \pmb y } = f _ { \pmb { \psi } } \left( { \pmb x } ; \pmb { \phi } \right) \triangleq f \left( { \pmb x } ; { \pmb g } ( { \pmb \phi } ; { \pmb \psi } ) \right) .
+$$
+
+Training of $f _ { \psi }$ is done by backpropagation further through $g$ , as $\begin{array} { r } { \frac { \partial } { \partial \phi } = \frac { \partial g } { \partial \phi } \frac { \partial } { \partial g } } \end{array}$ . If it is so chosen that $\dim ( \Phi ) < \dim ( \Theta )$ and $f _ { \psi } \approx f$ in terms of its generalization performance, then $f _ { \psi }$ is a more parameter efficient approximation of $f$ .
+
+Sparse reparameterization is a special case where $g$ is a linear projection; $\phi$ is the non-zero entries (i.e. “weights”) and $\psi$ their indices (i.e. “connectivity”) in the original parameter $\pmb \theta$ . Likewise, parameter sharing (or more generally linear constraints of parameters) is a similar special case of linear reparameterization where $\phi$ is the tied parameters and $\psi$ their indices. In this sense a convolution layer can be considered a reparameterization of a fully connected layer.
+
+Further, if metaparameters $\psi$ are fixed during the course of training, the reparameterization is static, whereas if $\psi$ is adjusted adaptively during training, we call it dynamic reparameterization.
+
+Now, the question is: given a full model $f$ , is it possible to find a more efficient reparameterization $f _ { \psi }$ that, trained de novo, can generalize comparably well? The success of various model compression techniques suggests that such reparameterizations might exist for most well-known models, and a recent study (Frankle & Carbin, 2018) made successful post hoc identifications of sparse reparameterized small networks with precisely such properties. Nevertheless, attempts at training small networks de novo typically yield results significantly underperforming networks obtained by compressing larger models (Zhu & Gupta, 2017). This has led to a commonly held belief that gross overparameterization is necessary for effective training. Here we argue that this is not true by presenting a dynamic sparse reparameterization technique able to train sparse models de novo without the need to compress a large model, a desirable feature for training on memory- and power-constrained devices.
+
+Our contributions are listed as follows.
+
+1. We showed that it is possible to train a small sparse network directly without a larger than inference-time parameter footprint at any stages of training, yet still achieving generalization performance at least on par with post-training iterative pruning of large dense models, yielding the most parameter efficient model at a given sparsity.
+
+2. We showed that our method is more scalable and efficient, and leads to significantly better accuracy than existing dynamic sparse reparameterization training techniques.
+
+# 2 RELATED WORK
+
+Training of differentiably reparameterized networks has been proposed in numerous studies before.
+
+Dense reparameterization Several dense reparameterization techniques sought to reduce the size of fully connected layers. These include low-rank decomposition (Denil et al., 2013), fastfood transform (Yang et al., 2014), ACDC transform (Moczulski et al., 2015), HashedNet (Chen et al., 2015), low displacement rank (Sindhwani et al., 2015) and block-circulant matrix parameterization (Treister et al., 2018).
+
+Note that similar reparameterizations were also used to introduce certain algebraic properties to the parameters for purposes other than reducing model sizes, e.g. to make training more stable as in unitary evolution RNNs (Arjovsky et al., 2015) and in weight normalization (Salimans & Kingma, 2016), to inject inductive biases (Thomas et al., 2018), and to alter (Dinh et al., 2017) or to measure (Li et al., 2018) properties of the loss landscape. All dense reparameterization methods to date are static.
+
+Sparse reparameterization Successful training of sparse reparameterized networks usually employs iterative pruning and retraining, e.g. Han et al. (2015); Narang et al. (2017); Zhu & Gupta (2017) 3. Training typically starts with a large pre-trained model and sparsity is gradually increased during the course of fine-tuning. Training a small, static, and sparse model de novo always fared much worse than training a large one to begin with (Zhu & Gupta, 2017).
+
+Frankle & Carbin (2018) successfully identified small and sparse subnetworks post-training which, when trained in isolation, reached a similar accuracy as the enclosing big network. They further showed that these subnetworks were sensitive to initialization, and hypothesized that the role of overparameterization is to provide a large number of candidate subnetworks, thereby increasing the likelihood that one of these subnetworks will have the necessary structure and initialization needed for effective learning.
+
+Most closely related to our work are dynamic sparse reparameterization techniques that emerged only recently. Like ours, these methods adaptively alter, by certain heuristic rules, reparameterization during training. Sparse evolutionary training (Mocanu et al., 2018) used magnitude-based pruning and random growth at the end of each training epoch. NeST (Dai et al., 2017; 2018) iteratively grew and pruned parameters and neurons during training; parameter growth was guided by gradient and pruning by magnitude. Deep rewiring (Bellec et al., 2017) combined sparse reparameterization with stochastic parameter updates for training. These methods were mostly concerned with sparsifying fully connected layers and applied to relatively small and shallow networks. We show that the method we propose in this paper is more scalable and computationally efficient than these previous approaches, while achieving better performance on deep convolutional networks.
+
+# 3 METHODS
+
+In this section, we describe our dynamic sparse reparameterization method. Some notations first. Let all reparameterized weight tensors in the original network be denoted by $\{ \boldsymbol { \mathsf { W } } _ { l } \}$ , where $l = 1 , \cdots , L$ indexes layers. Let $N _ { l }$ be the number of parameters in $\boldsymbol { \mathsf { W } } _ { l }$ , and $N = \textstyle \sum _ { l } \bar { N _ { l } }$ the total parameter count.
+
+Sparse reparameterize $\pmb { \mathsf { W } } _ { l } = g \left( \phi _ { l } ; \psi _ { l } \right)$ , where function $g$ places components of parameter $\phi _ { l }$ into positions in $\boldsymbol { \mathsf { W } } _ { l }$ indexed by $\psi _ { l } \in \Psi _ { M _ { l } } \left( \{ 1 , \cdot \cdot \cdot , N _ { l } \} \right) ^ { \angle }$ 4, s.t. $W _ { l , \psi _ { l , i } } = \phi _ { l , i } , \forall i$ indexing components. Let $M _ { l } < N _ { l }$ be the dimensionality of $\phi _ { l }$ and $\psi _ { l }$ , i.e. the number of non-zero weights in $\boldsymbol { \mathsf { W } } _ { l }$ . Define $\begin{array} { r } { s _ { l } = 1 - \frac { M _ { l } } { N _ { l } } } \end{array}$ as the sparsity of $\boldsymbol { \mathsf { W } } _ { l }$ . Global sparsity is then defined as $\begin{array} { r } { s = 1 - \frac { M } { N } } \end{array}$ where $\begin{array} { r } { M = \sum _ { l } M _ { l } } \end{array}$
+
+During the whole course of training, we kept global sparsity constant, specified by hyperparameter $s \in ( 0 , 1 )$ . Reparameterization was initialized by uniformly sampling positions in each weight tensor
+
+Input: $\left\{ \left( \phi _ { l } ^ { ( t ) } , \psi _ { l } ^ { ( t ) } \right) \right\}$ , M (t) , H (t) . From step t   
+Output: nφ(t+1)l , ψ(t+1)l o, M (t+1), H (t+1) . To step $t + 1$   
+Need: K, δ . Target number of parameters to be pruned and its fractional tolerance   
+1 for $l \in \{ 1 , \cdots , L \}$ do $\triangleright$ For each reparameterized weight tensor   
+2 $\Pi _ { l } ^ { ( t ) } \gets \left\{ i : \big | \phi _ { l , i } ^ { ( t ) } \big | < H ^ { ( t ) } \right\}$ . Indices of subthreshold components of $\phi _ { l } ^ { ( t ) }$ to be pruned   
+3 $\left( \boldsymbol { K } _ { l } ^ { ( t ) } , \boldsymbol { R } _ { l } ^ { ( t ) } \right) \gets \left( \big | \Pi _ { l } ^ { ( t ) } \big | , M _ { l } ^ { ( t ) } - \big | \Pi _ { l } ^ { ( t ) } \big | \right)$ . Numbers of pruned and surviving weights   
+4 if $\begin{array} { r } { \sum _ { l } K _ { l } ^ { ( t ) } < ( 1 - \delta ) K } \end{array}$ then $\triangleright$ Too few parameters pruned   
+5 $H ^ { ( t + 1 ) } \gets 2 H ^ { ( t ) }$ $\triangleright$ Increase pruning threshold   
+6 else if $\begin{array} { r } { \sum _ { l } K _ { l } ^ { ( t ) } > ( 1 + \delta ) K } \end{array}$ then . Too many parameters pruned   
+7 $\begin{array} { r } { H ^ { ( t + 1 ) } \gets \frac { 1 } { 2 } H ^ { ( t ) } } \end{array}$ $\triangleright$ Decrease pruning threshold   
+8 else . A proper number of parameters pruned   
+9 $H ^ { ( t + 1 ) }  H ^ { ( t ) }$ . Maintain pruning threshold   
+10 for $l \in \{ 1 , \cdots , L \}$ do . For each reparameterized weight tensor   
+11 $\begin{array} { r } { G _ { l } ^ { ( t ) } \gets \left\lfloor \frac { R _ { l } ^ { ( t ) } } { \sum _ { l } R _ { l } ^ { ( t ) } } \sum _ { l } K _ { l } ^ { ( t ) } \right\rceil } \end{array}$ . Redistribute parameters for growth   
+12 ψ˜(t)l ∼ U hΨG(t)l {1, · · · , Nl} \ nψ(t)l,i oi . Sample zero positions to grow new weights   
+13 14 M l ← M l − K l + G l φ ( t +1)l , ψ ( t +1)l  ←  φ ( t )l ,i /∈ Π ( t )l , 0  ,  ψ ( t )l ,i /∈ Π ( t )l , ψ˜ ( t )l  . New parameter count. New reparameterization
+
+at the global sparsity $s$ , i.e. $\boldsymbol { \psi } _ { l } ^ { ( 0 ) } \sim \mathcal { U } \left[ \boldsymbol { \Psi } _ { M _ { l } ^ { ( 0 ) } } \left( \left\{ 1 , \cdots , N _ { l } \right\} \right) \right] , \forall l$ , where $M _ { l } ^ { ( 0 ) } = \left\lfloor ( 1 - s ) N _ { l } \right\rceil$ .   
+Associated parameters $\phi _ { l } ^ { ( 0 ) }$ were randomly initialized.
+
+Dynamic reparameterization was done periodically by repeating the following steps during training: 1. Train the model (currently reparameterized by $\left\{ \left( \phi _ { l } ^ { ( t ) } , \psi _ { l } ^ { ( t ) } \right) \right\} )$ for $P$ batch iterations; 2. Reallocate free paramenew reparameterization $\left\{ \left( \phi _ { l } ^ { ( t + 1 ) } , \psi _ { l } ^ { ( t + 1 ) } \right) \right\}$ weight tensors following Algorithm 1 to arrive at.
+
+The adaptive reallocation is in essence a two-step procedure: a global pruning followed by a tensorwise growth. Specifically our algorithm has the following key features:
+
+• Pruning was based on magnitude of weights, by comparing all parameters to a global threshold $H$ , making the algorithm much more scalable than methods relying on layer-specific pruning. • We made $H$ adaptive, subject to a simple setpoint control dynamics that ensured roughly $K$ weights to be pruned globally per iteration. This proved to be much cheaper computationally than pruning exactly $K$ smallest weights, which requires sorting all weights in the network. • Growth was by uniformly sampling zero weights and tensor-specific, thereby achieving a reallocation of parameters across layers. The heuristic guiding growth is
+
+$$
+G _ { l } ^ { ( t ) } = \left\lfloor \frac { R _ { l } ^ { ( t ) } } { \sum _ { l } R _ { l } ^ { ( t ) } } \sum _ { l } K _ { l } ^ { ( t ) } \right\rceil ,
+$$
+
+where K(t) and $R _ { l } ^ { ( t ) } = M _ { l } ^ { ( t ) } - K _ { l } ^ { ( t ) }$ are the pruned and surviving parameter counts, respectively. This rule allocated more free parameters to weight tensors with more surviving entries, while keeping the global sparsity the same by balancing numbers of parameters pruned and grown 5.
+
+Table 1: Datasets and models used in experiments   
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=2>|MNIST           CIFAR10</td><td rowspan=1 colspan=1>|Imagenet</td></tr><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=2>|LeNet-300-100  |WRN-28-2(LeCun et al.,1998)[(Zagoruyko &amp; Komodakis,2016)</td><td rowspan=1 colspan=1>Resnet-50(He et al., 2015)</td></tr><tr><td rowspan=1 colspan=1>Architecture</td><td rowspan=1 colspan=1>F300F100F10</td><td rowspan=1 colspan=1>C16/3×3[C16/3×3,C16/3×3]×4[C64/3×3,C64/3 ×3]×4[C128/3×3,C128/3×3]×4GlobalAvgPool,F10</td><td rowspan=1 colspan=1>C64/7×7-2,MaxPool/3×3-2[C64/1×1,C64/3×3,C256/1×1]×3[C128/1×1,C128/3×3,C512/1×1]×4[C256/1×1,C256/3×3,C1024/1×1]×6[C512/1×1,C512/3×3,C2048/1×1]×3GlobalAvgPool,F100</td></tr><tr><td rowspan=1 colspan=1># Parameters|267K</td><td rowspan=1 colspan=2>|1.5M</td><td rowspan=1 colspan=1>|25.6M</td></tr></table>
+
+For brevity architecture specifications omit batch normalization and activations. Fully connected (F) and convolutional (C) layers are specified with output size and kernel size, Max pooling (MaxPool) with kernel size and none with global average pooling (GlobalAvgPool). Brackets enclose residual blocks postfixed with repetition numbers; downsampling convolution in the first block of a scale group is implied.
+
+The entire procedure can be fully specified by hyperparameters $( s , P , K , \delta , H ^ { ( 0 ) } )$ . For specific values used in experiments see implementational details in Appendix A.
+
+# 4 EXPERIMENTAL RESULTS
+
+We evaluated our method in three sets of experiments (Table 1). We chose more modern convolutional networks, Resnet (He et al., 2015) and Wide Resnet (Zagoruyko & Komodakis, 2016), with parameter efficiency superior to earlier models, e.g. AlexNet (Krizhevsky et al., 2012) and VGG (Simonyan & Zisserman, 2014), thanks to the adoption of skip connections and use of global average pooling over fully connected layers. Such a setup makes a much stronger case for our method because compression is much harder for these recent models. Pre-activation batch normalization was used in all cases.
+
+Dynamic sparse reparameterization was applied to all weight tensors of fully connected and convolutional layers (with the exception of downsampling convolutions and the first convolutional layer taking the input image), while all biases and parameters of normalization layers were kept dense 6.
+
+At a specific sparsity $s$ , we compared our method (dynamic sparse) against six baselines:
+
+• Full dense: original large and dense model, with $N$ parameters;   
+• Thin dense: original model with less wide layers, such that it had $( 1 - s ) N$ parameters;   
+• Static sparse: original model reparameterized to sparsity $s$ , then trained with connectivity fixed;   
+• Compressed sparse: state-of-the-art compression of the original model by iterative pruning and retraining the original model to target sparsity $s$ (Zhu & Gupta, 2017);   
+• DeepR: sparse model trained by using Deep Rewiring (Bellec et al., 2017);   
+• SET: sparse model trained by using Sparse Evolutionary Training (Mocanu et al., 2018).
+
+Note that compressed sparse is a compression method that starts training with a dense model, whereas DeepR and SET, like ours, are dynamic reparameterization techniques that maintain sparsity throughout training. See Appendix A for hyperparameters used in the experiments.
+
+LeNet-300-100 on MNIST Like previous work on post-training compression, e.g. Han et al. (2015), and dynamic reparameterization, e.g. Bellec et al. (2017), we first experimented with a simple LeNet-300-100 trained on MNIST. We found that static sparse grossly underperformed compressed sparse, a gap effectively closed by our dynamic sparse method (Figure 1a) with the following nuances. Dynamic sparse slightly outperformed compressed sparse at very high sparsity (i.e. low parameter count), a trend reversed, albeit weakly, at lower sparsities.
+
+A breakdown of post-training sparsities across layers of the network (Figure 1b) reveals reliable patterns emerged from the dynamics of our adaptive reparameterization algorithm. This is consistent with previous observations (Bellec et al., 2017) that, given a fixed global sparsity, it was wiser to allocate more free parameters to the last layer, than to impose constant sparsity on all layers.
+
+![](images/2a22d1484ca8a763fffdf4677ae83a6e22912c5a4070467cf93a672065f1eb09.jpg)  
+Figure 1: LeNet-300-100 on MNIST. (a) Test accuracy plotted against number of trainable parameters for different methods. Dashed lines are used for full dense model and for compression methods, whereas all reparameterization methods maintaining a fixed sparsity level throughout training are represented by solid lines. Circular symbols mark the median of 5 runs, error bars standard deviation. Parameter counts include all trainable parameters, i.e. reparameterized sparse paremeter tensors plus all other parameter tensors that were kept dense, such as those of batch normalization layers. For small numbers of trainable parameters, the static sparse model fails to learn (not shown, out of ordinate range). (b) Layer-wise breakdown of final sparsities emerged from our dynamic sparse parameterization algorithm (Algorithm 1) at different levels of overall sparsity. Mean and standard deviation from 5 runs.
+
+![](images/06e715f6b30ebe24d188b7dc4e607c18b0fc7f12cb8d1ec2b47b961a68d63084.jpg)  
+Figure 2: WRN-28-2 on CIFAR10. (a) Test accuracy plotted against number of trainable parameters for different methods. Conventions same as in Figure 1a. (b) Breakdown of final sparsities emerged from our dynamic sparse parameterization algorithm (Algorithm 1) at different levels of global sparsity. (c) A further breakdown of final sparsities of individual residual blocks in the WRN groups at three scales, at the overall sparsity of 0.6. (d) Same as (c) at overall sparsity of 0.8. All results in (b, c & d) are mean and standard deviation from 5 runs.
+
+WRN-28-2 on CIFAR10 Next, we experimented with a Wide Resnet model WRN-28-2 (Zagoruyko & Komodakis, 2016) trained to classify CIFAR10 images (see Appendix A for details of implementation). As shown in Figure 2a, static sparse and thin dense significantly underperformed the state-of-the-art compressed sparse model, whereas our method dynamic sparse significantly outperformed it. Deep rewiring significantly lagged all other method. While the performance of SET was on par with compressed sparse, it lagged behind dynamic sparse at high sparsity levels. At low sparsity levels SET largely closed the gap to compressed sparse.
+
+Table 2: Test accuracy $\%$ (top-1, top-5) of Resnet-50 trained on Imagenet   
+
+<table><tr><td colspan="3">Final overall sparsity (# Parameters) |</td><td colspan="2">0.8 (7.3M)</td><td>0.9 (5.1M)</td><td colspan="2">0.0 (25.6M)</td></tr><tr><td rowspan="2">Reparameterization</td><td>static</td><td>Thin dense Static sparse DeepR</td><td>71.6 [-3.3] 70.4 [-4.5] 1</td><td>90.3 [-2.1] 89.8 [-2.6] 1</td><td>69.4 89.2 [-5.5] [-3.2] 66.4 87.4 [-8.5] [-5.0] 1 1</td><td rowspan="2">74.9 92.4 [0.0] [0.0]</td></tr><tr><td>dynamic</td><td>(Bellec et al., 2017) SET (Mocanu et al., 2018) Dynamic sparse (Ours)</td><td>[-] 72.6 [-2.3] 73.3 [-1.6]</td><td>[-] 91.2 [-1.2] 92.4 [0.0]</td><td>[-] [-] 70.4 90.1 [-4.5] [-2.3] 71.6 90.5 [-3.3] [-1.9]</td></tr><tr><td colspan="2" rowspan="2">Compression</td><td>Compressed sparse (Zhu &amp; Gupta, 2017) ThiNet</td><td>73.2 [-1.7] 68.4</td><td>91.5 [-0.9]</td><td>70.3 90.0 [-4.6] [-2.4]</td><td colspan="2"></td></tr><tr><td>(Luo et al., 2017) sss (Huang &amp; Wang,2017)</td><td>[-4.5] 71.8 [-4.3]</td><td>88.3 [-2.8] 90.8 [-2.1]</td><td></td><td colspan="2">(at 8.7M parameter count) (at 15.6M parameter count)</td></tr></table>
+
+Numbers in square brackets are differences from the full dense baseline. Romanized numbers are results of our experiments, and italicized ones taken directly from the original paper. Performance of two structured pruning methods, ThiNet and Sparse Structure Selection (SSS), are also listed for comparison (below the double line, see Appendix C for discussion of their relevance); note the difference in parameter counts.
+
+![](images/2525aa5a0549c82c30332fdb2668f102cc13fa841e5451fbf2b51646dcab2379.jpg)  
+Figure 3: Block-wise breakdown of final sparsities of Resnet-50 trained on Imagenet. (a) At overall sparsity 0.8. Similar to Figure 2c. (b) Same as (a) at overall sparsity of 0.9.
+
+Again, consistent sparsity patterns emerged from the adaptive reparameterization dynamics of Algorithm 1 (Figure 2b, c & d). We observed two rough trends: (a) larger parameter tensors tended to be sparser than smaller ones, and (b) deeper layers tended to be sparser than shallower ones.
+
+Resnet-50 on Imagenet Finally, we experimented with the Resnet-50 bottleneck architecture (He et al., 2015) trained on Imagenet (see Appendix A for details of implementation). We tested two global sparsity levels, 0.8 and 0.9 (Table 2). Again, our method (dynamic sparse) outperformed state-of-the-art sparse compression (compressed sparse), which in turn outperformed static sparse and thin dense baselines. We also list in Table 2 two representative methods of structured pruning (see Appendix C), ThiNet (Luo et al., 2017) and Sparse Structure Selection (Huang & Wang, 2017), which, consistent with recent criticisms (Liu et al., 2018), underperformed static dense baselines.
+
+Consistent with the aforementioned experiments with LeNet-100-10 and WRN-28-2, reliable sparsity patterns across layers emerged from dynamic parameter reallocation during training, displaying the same empirical trends described above (Figure 3).
+
+Computational overhead of dynamic reparameterization We assessed the additional computational cost incurred by reparameterization steps (Algorithm 1) during training, and compared ours with existing dynamic sparse reparameterization techniques, DeepR and SET (Table 3). Because both SET and ours reallocate parameters only intermittently (every few hundred training iterations), the computational overhead was negligible for the experiments presented here7. DeepR, however, requires adding noise to gradient updates as well as reallocating parameters every training iteration, and therefore led to a significantly larger overhead.
+
+Table 3: Computational overhead of dynamic reparameterization during training   
+
+<table><tr><td></td><td>WRN-28-2 on CIFAR10</td><td>Resnet-50 on Imagenet</td></tr><tr><td>DeepR (Bellec et al., 2017)</td><td>4.466 ± 0.358</td><td>5.636 ± 0.218</td></tr><tr><td>SET (Mocanu et al., 2018)</td><td>1.087 ± 0.049</td><td>1.009 ± 0.002</td></tr><tr><td>Dynamic sparse (Ours)</td><td>1.083 ± 0.051</td><td>1.005 ± 0.004</td></tr></table>
+
+Shown are median ratios of wall-clock epoch times for training with over without reparameterization, standard deviation estimated from 25 epochs. WRN-28-2 on CIFAR10 was trained on a single Nvidia Titan $\mathrm { X p }$ GPU, and Resnet-50 on Imagenet on four with data parallelism (also see Appendix A for implementation details).
+
+# 5 DISCUSSION
+
+In this work, we described and validated the best known solution so far to the following problem: given a small, fixed budget of parameters for a deep CNN throughout training time, how to train it to yield the best generalization performance. Our method used a dynamic reparameterization technique that adaptively reallocated free parameters across the network based on a simple heuristic. We demonstrated that this method not only fared much better than static reparameterization techniques, but also significantly outperformed even the state-of-the-art sparse compression methods. Note that compression is a much more forgiving situation where the parameter budget is not imposed during the entire course, but only at the end, of training.
+
+Thus, our method yielded the most parameter efficient sparse reparameterization of a given CNN. The past few years have seen a steady improvement in parameter efficiency of state-of-the-art CNN models thanks to innovations in network architectures. Specifically, the introduction of residual modules and the use of global pooling in place of fully connected layers are largely responsible, as convolutional layers are more parameter efficient than fully connected layers in general. For example, AlexNet (Krizhevsky et al., 2012) had a majority of its parameters in fully connected layers, and this fraction has been decreasing in VGG (Simonyan & Zisserman, 2014), Inception (Szegedy et al., 2014), and more recently in Resnets (He et al., 2015) it was reduced to close to none. Meanwhile, compact architectures with far fewer parameters also emerged at reasonable costs of performance degradation, e.g. SqueezeNet (Iandola et al., 2016) and MobileNet (Howard et al., 2017), for niche use cases where computing resources are limited.
+
+Here we took a different, but complementary, approach. Instead of searching the space of network architectures for new models with superior parameter efficiency, we sought to reparameterize a given model to make it more parameter efficient. Such techniques have a history as long as modern convolutional networks. Most early methods used dense reparameterization (Denil et al., 2013; Yang et al., 2014; Moczulski et al., 2015; Sindhwani et al., 2015), effective in reducing redundancy in fully connected layers of big sizes, such as in AlexNet. These became less relevant as models became increasingly free of large linear layers but heavy in convolutional ones 8.
+
+Sparse reparameterization, on the other hand, has been shown useful in compression of state-of-the-art deep CNNs (Han et al., 2015; Narang et al., 2017). However, a prominent empirical observation from these compression studies is that training a small sparse model de novo could never reach the same accuracy achieved by one of the same size compressed down from a large model (Zhu & Gupta, 2017). Why does it seem impossible to train a compact network but easy to compress a large one?
+
+The “lottery ticket hypothesis” (Frankle & Carbin, 2018) offered a plausible explanation. The authors identified, by post-training pruning, trainable sparse models that, albeit sensitive to initialization, generalized comparably well (called “winning tickets”). They further posited that, the necessity of starting training with a large model is because only a big network with combinatorially a huge number of small subnetworks has a high probability of “winning the initialization lottery”. Similarly, here we argue that post hoc identification of trainable compact (not necessarily sparse) reparameterization is actually rather trivial also because the optimization trajectory is typically a very low-dimensional object. Take for example the training of Resnet-152 (parameter count 60.2M) as described by He et al. (2015): parameter updates for 600K iterations reliably send a random initialization to a state-of-the-art solution. One could simply take a trivial post hoc reparameterization as a linear projection onto the span of the 600K parameter updates which, even if they are all linearly independent from each other, amount to less than $1 \%$ of the total parameter count. The low dimensionality of optimization trajectory is consistent with emerging evidence suggesting that optima of overparameterized deep neural networks are usually high-dimensional manifolds with low co-dimensions (Cooper, 2018), and that such optima have superior generalization properties (Wu et al., 2017) and favored by SGD (Zhang et al., 2018a; Poggio et al., 2017).
+
+What prohibits any post hoc reparameterized compact model from being effectively trained de novo is however its sensitivity to initialization–though optimization trajectories are each low-dimensional, their linear spans do not necessarily overlap when starting from different initial points. An obvious way “to win the lottery” is to purchase all available tickets (i.e. having a huge model to cover all possible linear spans of optimization trajectories), but it is also conceivably feasible “to cheat” by adaptively changing the number on a single ticket as the lottery result is being announced (i.e. dynamic reparameterization that continually re-orients a low-dimensional parameter manifold tangentially along an optimization trajectory). We believe our method did exactly this.
+
+We were inspired by previous methods of dynamic sparse reparameterization, e.g. DeepR (Bellec et al., 2017) and SET (Mocanu et al., 2018) (also see Appendix C). Compared to these techniques, our method has a number of advantages. First, ours produced better performing sparse CNNs, fully closed the gap to compression of large dense models. Second, our reparameterization incurred the least computational overhead during training by infrequent and cheap parameter reallocation. Finally, our method is highly scalable thanks to its automatic reallocation of parameters across layers, without the need of manually configuring sparsity for each layer 9.
+
+A noteworthy observation from our experiments is that the highest parameter efficiency was achieved by non-structured sparsification (see Appendix C for details). Accuracy suffered significantly when structure was imposed on the sparsity patterns (see Appendix D). Because computations involving fine-grained sparsity cannot be readily accelerated on GPUs, a number of compression methods by structured pruning (see Appendix C) remove entire channels from deep CNNs to yield smaller networks with dense parameter tensors. However, many of these structured pruning methods produced compressed models no better than direct training of a thin dense model (Liu et al., 2018) (also see Table 2 for examples compared with our method).
+
+Our findings suggest that it is possible to train sparse models directly to reach generalization performances equal to or better than those of dense or sparse networks of comparable size produced by compression. This warrants a renewed look at the practical choices of best hardware architectures for training, between computing devices optimized for dense linear algebra versus those suited for sparse operations.
+
+# REFERENCES
+
+Martin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary Evolution Recurrent Neural Networks. nov 2015. URL http://arxiv.org/abs/1511.06464.
+
+Guillaume Bellec, David Kappel, Wolfgang Maass, and Robert Legenstein. Deep Rewiring: Training very sparse deep networks. nov 2017. URL http://arxiv.org/abs/1711.05136.
+
+Alon Brutzkus, Amir Globerson, Eran Malach, and Shai Shalev-Shwartz. SGD Learns Overparameterized Networks that Provably Generalize on Linearly Separable Data. oct 2017. URL http://arxiv.org/abs/1710.10174.
+
+Cristian Bucilua, Rich Caruana, and Alexandru Niculescu-Mizil. Model Compression. Technical report, 2006. URL https://www.cs.cornell.edu/{˜}caruana/compression. kdd06.pdf.
+
+Wenlin Chen, James T. Wilson, Stephen Tyree, Kilian Q. Weinberger, and Yixin Chen. Compressing Neural Networks with the Hashing Trick. apr 2015. URL http://arxiv.org/abs/1504. 04788.
+
+Anna Choromanska, Mikael Henaff, Michael Mathieu, Gerard Ben Arous, and Yann LeCun. The Loss ´ Surfaces of Multilayer Networks. nov 2014. URL http://arxiv.org/abs/1412.0233.
+
+Y Cooper. The loss landscape of overparameterized neural networks. apr 2018. URL http: //arxiv.org/abs/1804.10200.
+
+Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized Neural Networks: Training Deep Neural Networks with Weights and Activations Constrained to $+ 1$ or -1. feb 2016. URL http://arxiv.org/abs/1602.02830.
+
+Xiaoliang Dai, Hongxu Yin, and Niraj K. Jha. NeST: A Neural Network Synthesis Tool Based on a Grow-and-Prune Paradigm. pp. 1–15, 2017. URL http://arxiv.org/abs/1711.02017.
+
+Xiaoliang Dai, Hongxu Yin, and Niraj K. Jha. Grow and Prune Compact, Fast, and Accurate LSTMs. may 2018. URL http://arxiv.org/abs/1805.11797.
+
+Yann Dauphin, Razvan Pascanu, Caglar Gulcehre, Kyunghyun Cho, Surya Ganguli, and Yoshua Bengio. Identifying and attacking the saddle point problem in high-dimensional non-convex optimization. arXiv, pp. 1–14, 2014. URL http://arxiv.org/abs/1406.2572.
+
+Misha Denil, Babak Shakibi, Laurent Dinh, Marc’Aurelio Ranzato, and Nando de Freitas. Predicting Parameters in Deep Learning. jun 2013. URL http://arxiv.org/abs/1306.0543.
+
+Laurent Dinh, Razvan Pascanu, Samy Bengio, and Yoshua Bengio. Sharp Minima Can Generalize For Deep Nets. 2017. ISSN 1938-7228. URL http://arxiv.org/abs/1703.04933.
+
+Jonathan Frankle and Michael Carbin. The Lottery Ticket Hypothesis: Finding Small, Trainable Neural Networks. mar 2018. URL http://arxiv.org/abs/1803.03635.
+
+Ian J. Goodfellow, Oriol Vinyals, and Andrew M. Saxe. Qualitatively characterizing neural network optimization problems. dec 2014. URL http://arxiv.org/abs/1412.6544.
+
+Song Han, Jeff Pool, John Tran, and William J. Dally. Learning both Weights and Connections for Efficient Neural Networks. jun 2015. URL http://arxiv.org/abs/1506.02626.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep Residual Learning for Image Recognition. Arxiv.Org, 7(3):171–180, 2015. ISSN 1664-1078. doi: 10.3389/fpsyg.2013.00124. URL http://arxiv.org/pdf/1512.03385v1.pdf.
+
+Yihui He, Xiangyu Zhang, and Jian Sun. Channel Pruning for Accelerating Very Deep Neural Networks. jul 2017. URL http://arxiv.org/abs/1707.06168.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the Knowledge in a Neural Network. pp. 1–9, 2015. ISSN 0022-2488. doi: 10.1063/1.4931082. URL http://arxiv.org/abs/ 1503.02531.
+
+Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications. apr 2017. URL http://arxiv.org/abs/1704.04861.
+
+Zehao Huang and Naiyan Wang. Data-Driven Sparse Structure Selection for Deep Neural Networks. jul 2017. URL https://arxiv.org/abs/1707.01213.
+
+Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Quantized Neural Networks: Training Neural Networks with Low Precision Weights and Activations. sep 2016. URL http://arxiv.org/abs/1609.07061.
+
+Forrest N. Iandola, Song Han, Matthew W. Moskewicz, Khalid Ashraf, William J. Dally, and Kurt Keutzer. SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and. feb 2016. URL http://arxiv.org/abs/1602.07360.
+
+Daniel Jiwoong Im, Michael Tao, and Kristin Branson. An empirical analysis of the optimization of deep network loss surfaces. dec 2016. URL http://arxiv.org/abs/1612.04010.
+
+Max Jaderberg, Andrea Vedaldi, and Andrew Zisserman. Speeding up Convolutional Neural Networks with Low Rank Expansions. may 2014. URL http://arxiv.org/abs/1405.3866.
+
+Urs Koster, Tristan J. Webb, Xin Wang, Marcel Nassar, Arjun K. Bansal, William H. Constable, ¨ Ouz H. Elibol, Scott Gray, Stewart Hall, Luke Hornof, Amir Khosrowshahi, Carey Kloss, Ruby J. Pai, and Naveen Rao. Flexpoint: An Adaptive Numerical Format for Efficient Training of Deep Neural Networks. nov 2017. URL http://arxiv.org/abs/1711.02213.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. ImageNet Classification with Deep Convolutional Neural Networks. Technical report, 2012.
+
+Vadim Lebedev and Victor Lempitsky. Fast ConvNets Using Group-wise Brain Damage. jun 2015. URL https://arxiv.org/abs/1506.02515.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2323, 1998. ISSN 00189219. doi: 10.1109/5.726791.
+
+Chunyuan Li, Heerad Farkhoor, Rosanne Liu, and Jason Yosinski. Measuring the Intrinsic Dimension of Objective Landscapes. apr 2018. URL http://arxiv.org/abs/1804.08838.
+
+Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning Filters for Efficient ConvNets. aug 2016. URL http://arxiv.org/abs/1608.08710.
+
+Qianli Liao and Tomaso Poggio. Theory of Deep Learning II: Landscape of the Empirical Risk in Deep Learning. arXiv, mar 2017. URL http://arxiv.org/abs/1703.09833.
+
+Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning Efficient Convolutional Networks through Network Slimming. aug 2017. URL https://arxiv. org/abs/1708.06519.
+
+Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. Rethinking the Value of Network Pruning. oct 2018. URL http://arxiv.org/abs/1810.05270.
+
+Jian-Hao Luo, Jianxin Wu, and Weiyao Lin. ThiNet: A Filter Level Pruning Method for Deep Neural Network Compression. jul 2017. URL http://arxiv.org/abs/1707.06342.
+
+Mark D. McDonnell. Training wide residual networks for deployment using a single bit for each weight. feb 2018. URL http://arxiv.org/abs/1802.08530.
+
+Deepak Mittal, Shweta Bhardwaj, Mitesh M. Khapra, and Balaraman Ravindran. Recovering from Random Pruning: On the Plasticity of Deep Convolutional Neural Networks. jan 2018. URL http://arxiv.org/abs/1801.10447.
+
+Decebal Constantin Mocanu, Elena Mocanu, Peter Stone, Phuong H. Nguyen, Madeleine Gibescu, and Antonio Liotta. Scalable training of artificial neural networks with adaptive sparse connectivity inspired by network science. Nature Communications, 9(1):2383, dec 2018. ISSN 2041- 1723. doi: 10.1038/s41467-018-04316-3. URL http://www.nature.com/articles/ s41467-018-04316-3.
+
+Marcin Moczulski, Misha Denil, Jeremy Appleyard, and Nando de Freitas. ACDC: A Structured Efficient Linear Layer. nov 2015. URL http://arxiv.org/abs/1511.05946.
+
+Sharan Narang, Erich Elsen, Gregory Diamos, and Shubho Sengupta. Exploring Sparsity in Recurrent Neural Networks. apr 2017. URL http://arxiv.org/abs/1704.05119.
+
+Roman Novak, Yasaman Bahri, Daniel A. Abolafia, Jeffrey Pennington, and Jascha Sohl-Dickstein. Sensitivity and Generalization in Neural Networks: an Empirical Study. feb 2018. URL http: //arxiv.org/abs/1802.08760.
+
+Tomaso Poggio, Kenji Kawaguchi, Qianli Liao, Brando Miranda, Lorenzo Rosasco, Xavier Boix, Jack Hidary, and Hrushikesh Mhaskar. Theory of Deep Learning III: explaining the non-overfitting puzzle. 2017. URL http://arxiv.org/abs/1801.00173.
+
+Tim Salimans and Diederik P. Kingma. Weight Normalization: A Simple Reparameterization to Accelerate Training of Deep Neural Networks. feb 2016. URL http://arxiv.org/abs/ 1602.07868.
+
+Noam Shazeer, Azalia Mirhoseini, Krzysztof Maziarz, Andy Davis, Quoc Le, Geoffrey Hinton, and Jeff Dean. Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer. jan 2017. URL https://arxiv.org/abs/1701.06538.
+
+Karen Simonyan and Andrew Zisserman. Very Deep Convolutional Networks for Large-Scale Image Recognition. sep 2014. URL http://arxiv.org/abs/1409.1556.
+
+Vikas Sindhwani, Tara N. Sainath, and Sanjiv Kumar. Structured Transforms for Small-Footprint Deep Learning. oct 2015. URL http://arxiv.org/abs/1510.01722.
+
+Xavier Suau, Luca Zappella, and Nicholas Apostoloff. Network Compression using Correlation Analysis of Layer Responses. jul 2018. URL http://arxiv.org/abs/1807.10585.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going Deeper with Convolutions. sep 2014. URL http://arxiv.org/abs/1409.4842.
+
+Anna T Thomas, Albert Gu, Tri Dao, Atri Rudra, and R Christopher. Learning invariance with compact transforms. pp. 1–7, 2018.
+
+Eran Treister, Lars Ruthotto, Michal Sharoni, Sapir Zafrani, and Eldad Haber. Low-Cost Parameterizations of Deep Convolution Neural Networks. may 2018. URL http://arxiv.org/abs/ 1805.07821.
+
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning Structured Sparsity in Deep Neural Networks. 2016. ISSN 0028-0836. doi: 10.1109/HPCA.2015.7056066. URL https://papers.nips.cc/paper/ 6504-learning-structured-sparsity-in-deep-neural-networks.pdf.
+
+Lei Wu, Zhanxing Zhu, and Weinan E. Towards Understanding Generalization of Deep Learning: Perspective of Loss Landscapes. jun 2017. URL http://arxiv.org/abs/1706.10239.
+
+Zichao Yang, Marcin Moczulski, Misha Denil, Nando de Freitas, Alex Smola, Le Song, and Ziyu Wang. Deep Fried Convnets. dec 2014. URL http://arxiv.org/abs/1412.7149.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide Residual Networks. may 2016. URL http: //arxiv.org/abs/1605.07146.
+
+Chiyuan Zhang, Qianli Liao, Alexander Rakhlin, Brando Miranda, Noah Golowich, and Tomaso Poggio. Theory of Deep Learning IIb: Optimization Properties of SGD. jan 2018a. URL http://arxiv.org/abs/1801.02254.
+
+Tianyun Zhang, Shaokai Ye, Kaiqi Zhang, Jian Tang, Wujie Wen, Makan Fardad, and Yanzhi Wang. A Systematic DNN Weight Pruning Framework using Alternating Direction Method of Multipliers. apr 2018b. URL http://arxiv.org/abs/1804.03294.
+
+Michael Zhu and Suyog Gupta. To prune, or not to prune: exploring the efficacy of pruning for model compression. 2017. URL http://arxiv.org/abs/1710.01878.
+
+# APPENDIX A DETAILS OF IMPLEMENTATION
+
+We implemented all models and reparameterization mechanisms using pytorch. Experiments were run on GPUs, and all sparse tensors were represented as dense tensors filtered by a binary mask 10. Source code to reproduce all experiments is available on GitHub:
+
+Link suppressed for the sake of anonymity during review process.
+
+Training Hyperparameter settings for training are listed in the first block of Table 4. Standard mild data augmentation was used in all experiments for CIFAR10 (random translation, cropping and horizontal flipping) and for Imagenet (random cropping and horizontal flipping).
+
+Sparse compression baseline We compared our method against iterative pruning methods (Han et al., 2015; Zhu & Gupta, 2017). We start from a full dense model trained with hyperparameters provided in the first block of Table 4 and then gradually prune the network to a target sparsity in $T$ steps. As in Zhu & Gupta (2017), the pruning schedule we used was
+
+$$
+s ^ { ( t ) } = s + ( 1 - s ) \left( 1 - \frac { t } { T } \right) ^ { 3 } ,
+$$
+
+where $t = 0 , 1 , \cdots , T$ indexes pruning steps, and $s$ the target sparsity reached at the end of training. Thus, this baseline (labeled as compressed sparse in the paper) was effectively trained for more iterations (original training phase plus compression phase) than our dynamic sparse method, to the best of our knowledge a so far strongest baseline to benchmark our method.
+
+Hyperparameter settings for sparse compression are listed in the second block of Table 4.
+
+Dynamic reparameterization (ours) Hyperparameter settings for dynamic sparse reparameterization (Algorithm 1) are listed in the third block of Table 4.
+
+Sparse Evolutionary Training (SET) Because the larger-scale experiments here (WRN-28-2 on CIFAR10 and Resnet-50 on Imagenet) were not attempted by Mocanu et al. (2018), no specific settings for reparameterization in these cases were available in the original paper. In order to make a fair comparison, we used the same hyperparameters as those used in our dynamic reparameterization scheme (third block in Table 4). At each reparameterization step, the weights in each layer were sorted by magnitude and the smallest fraction was pruned. An equal number of parameters were then randomly allocated in the same layer and initialized to zero. For control, the total number of reallocated weights at each step was chosen to be the same as our dynamic reparameterization method, as was the schedule for reparameterization.
+
+Deep Rewiring (DeepR) The fourth block in Table 4 contain hyperparameters for the DeepR experiments. We refer the reader to Bellec et al. (2017) for details of the deep rewiring algorithm and for explanation of the hyperparameters.
+
+Exceptions For reasons described below, we made a few minor exceptions in sparsification for certain model layers in our experiments.
+
+• The sparsity of the last linear layer in LeNet-300-100 was allowed to be sparsified to at most $9 0 \%$ sparsity. In cases where global sparsity was over $9 0 \%$ , we redistribute free parameters from earlier layers to maintain the total parameter count. This is because, if the last layer was allowed to be overly sparse, performance sustained huge degradation unsuited for meaningful comparison. • The last linear layer of WRN-28-2 was always kept dense. It has a negligible fraction of parameter count.
+
+Table 4: Hyperparameters for all experiments presented in the paper   
+
+<table><tr><td rowspan=1 colspan=1>Experiment</td><td rowspan=1 colspan=1>LeNet-300-100on MNIST</td><td rowspan=1 colspan=1>WRN-28-2on CIFAR10</td><td rowspan=1 colspan=1>Resnet-50 on Imagenet</td></tr><tr><td rowspan=1 colspan=4> Hyperparameters for training</td></tr><tr><td rowspan=1 colspan=1>Number of training epochs</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>200</td><td rowspan=1 colspan=1>100</td></tr><tr><td rowspan=1 colspan=1>Mini-batch size</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>Learning rate schedule(epoch range: learning rate)</td><td rowspan=1 colspan=1>1-25:0.10026-50:0.02051 - 75:0.04076 - 100:0.008</td><td rowspan=1 colspan=1>1-60:0.10061 - 120:0.020121 - 160:0.040161 -200:0.008</td><td rowspan=1 colspan=1>1-30: 0.100031 - 60: 0.010061 -90: 0.001091- 100: 0.0001</td></tr><tr><td rowspan=1 colspan=1>Momentum (Nesterov)</td><td rowspan=1 colspan=1>0.9</td><td rowspan=1 colspan=1>0.9</td><td rowspan=1 colspan=1>0.9</td></tr><tr><td rowspan=1 colspan=1>L1 regularization multiplier</td><td rowspan=1 colspan=1>0.0001|</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>0.0</td></tr><tr><td rowspan=1 colspan=1>L² regularization multiplier</td><td rowspan=1 colspan=1>0.0</td><td rowspan=1 colspan=1>0.0005</td><td rowspan=1 colspan=1>0.0001</td></tr><tr><td rowspan=1 colspan=4> Hyperparameters for sparse compression (compressed sparse) (Zhu &amp; Gupta, 2017)</td></tr><tr><td rowspan=1 colspan=1>Number of pruning iterations (T)</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>20</td></tr><tr><td rowspan=1 colspan=1>Number of training epochsbetween pruning iterations</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1> Number of training epochs post-pruning</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>Number of epochs during pruning</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=1>50</td></tr><tr><td rowspan=1 colspan=1> Learning rate schedule during pruning(epoch range: learning rate)</td><td rowspan=1 colspan=1>1- 20: 0.0200|21-30:0.004031-40:0.0008</td><td rowspan=1 colspan=1>1- 25: 0.0200|25-35:0.004036-50:0.0008</td><td rowspan=1 colspan=1>1- 25: 0.010026 -35: 0.001036 -50: 0.0001</td></tr><tr><td rowspan=1 colspan=4>Hyperparameters for dynamic sparse reparameterization (dynamic sparse) (ours)</td></tr><tr><td rowspan=1 colspan=1>Number of parameters to prune (K)</td><td rowspan=1 colspan=1>600</td><td rowspan=1 colspan=1>20,000</td><td rowspan=1 colspan=1>200,000</td></tr><tr><td rowspan=1 colspan=1>Fractional tolerance of K (d)</td><td rowspan=1 colspan=1>0.1|</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.1</td></tr><tr><td rowspan=1 colspan=1>Initial pruning threshold (H())</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>0.001|</td><td rowspan=1 colspan=1>0.001</td></tr><tr><td rowspan=3 colspan=1>Reparameterization period (P) schedule(epoch range: P)</td><td rowspan=3 colspan=1>1-25:  10026-50:  20051-75:  40076 - 100:  800</td><td rowspan=1 colspan=1>1-25:  10026-80:  200</td><td rowspan=1 colspan=1>1-25: 100026-50: 2000</td></tr><tr><td rowspan=1 colspan=1>81 -140:  400</td><td rowspan=1 colspan=1>51-75: 4000</td></tr><tr><td rowspan=1 colspan=1>141 - 200:  800</td><td rowspan=1 colspan=1>76 - 100: 8000</td></tr><tr><td rowspan=1 colspan=4>Hyperparameters for Sparse Evolutionary Training (SET) (Mocanu et al., 2018)</td></tr><tr><td rowspan=1 colspan=1>Number of parameters to pruneat each re-parameterization step</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>20,000</td><td rowspan=1 colspan=1>200,000</td></tr><tr><td rowspan=1 colspan=1>Reparameterization period (P) schedule(epoch range: P)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1-25:  10026-80:  20081 -140:  400141 - 200:  800</td><td rowspan=1 colspan=1>1-25: 100026-50: 200051-75: 400076 - 100: 8000</td></tr><tr><td rowspan=1 colspan=4>Hyperparameters for Deep Rewiring (DeepR) (Bellec et al., 2017)</td></tr><tr><td rowspan=1 colspan=1>L1 regularization multiplier (α)</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>10-5</td><td rowspan=1 colspan=1>10-5</td></tr><tr><td rowspan=3 colspan=1>Temperature (T) schedule(epoch range: T)</td><td rowspan=3 colspan=1></td><td rowspan=2 colspan=1>1-25:10-526-80:10-8</td><td rowspan=1 colspan=1>1- 25:10-5</td></tr><tr><td rowspan=1 colspan=1>26-50:10-8</td></tr><tr><td rowspan=1 colspan=1>81 - 140:10-12141-200:10-15</td><td rowspan=1 colspan=1>51-75:10-1276-100:10-15</td></tr></table>
+
+# APPENDIX B COMPARISON TO STATIC DENSE REPARAMETERIZATION METHODS
+
+We also compared our dynamic sparse reparameterization method to a number of static dense reparameterization techniques, e.g. Denil et al. (2013); Yang et al. (2014); Moczulski et al. (2015); Sindhwani et al. (2015); Chen et al. (2015); Treister et al. (2018). Instead of sparsification, these methods impose structure on large parameter tensors by parameter sharing. Most of these methods have not been used for convolutional layers except for recent ones (Chen et al., 2015; Treister et al., 2018). We found that HashedNet (Chen et al., 2015) had the best performance over other static dense reparameterization methods, and also benchmarked our method against it. Instead of reparameterizing a parameter tensor with $N$ entries to a sparse one with $M < N$ non-zero components, HashedNet’s reparameterization is to put $M$ free parameters into $N$ positions in the parameter through a random mapping from $\{ 1 , \cdots , N \}$ to $\{ 1 , \cdots , M \}$ computed by cheap hashing, resulting in a dense parameter tensor with shared components.
+
+Results of LeNet-300-100-10 on MNIST are presented in Figure 4a, those of WRN-28-2 on CIFAR10 in Figure 4b, and those of Resnet-50 on Imagenet in Table 5. For a certain global sparsity $s$ of our method, we compare it against a HashedNet with all reparameterized tensor hashed such that each had a fraction $1 - s$ of effective parameter count. We found that our method dynamic sparse significantly outperformed HashedNet.
+
+![](images/976d8fa0c6e1503a65998c336e88a08081f70668135b01f45b46739afa666424.jpg)  
+Figure 4: Comparison to HashedNet. (a) Test accuracy for LeNet-300-100-10 trained on MNIST. (b) Test accuracy for WRN-28-2 trained on CIFAR10. Conventions same as in Figure 1a.
+
+Table 5: Test accuracy $\%$ (top-1, top-5) of Resnet-50 on Imagenet for dynamic sparse vs. HashedNet   
+
+<table><tr><td>Final overall sparsity (# Parameters)</td><td>0.8 (7.3M)</td><td></td><td>0.9 (5.1M)</td></tr><tr><td>HashedNet</td><td>70.0 [-4.9]</td><td>89.6 [-2.8]</td><td>66.9 [-8.0] 87.4 [-5.0]</td></tr><tr><td>Dynamic sparse (ours)</td><td>73.3 [-1.6]</td><td>92.4 [0.0]</td><td>71.6 [-3.3] 90.5 [-1.9]</td></tr></table>
+
+Numbers in square brackets are differences from the full dense baseline.
+
+# APPENDIX C A TAXONOMY OF TRAINING METHODS THAT YIELD “SPARSE” DEEP CNNS
+
+As an extension to Section 2 of the main text, here we elaborate on existing methods related to ours, how they compare with and contrast to each other, and what features, apart from effectiveness, distinguished our approach from all previous ones. We confine the scope of comparison to training methods that produce smaller versions (i.e. ones with fewer parameters) of a given modern (i.e. post-AlexNet) deep convolutional neural network model. We list representative methods in Table 6.
+
+We classify these methods by three key features.
+
+Strict parameter budget throughout training and inference This feature was discussed in depth in the main text. Most of the methods to date are compression techniques, i.e. they start training with a fully parameterized, dense model, and then reduce parameter counts. To the best of our knowledge, only three methods, namely DeepR (Bellec et al., 2017), SET (Mocanu et al., 2018) and ours, strictly impose, throughout the entire course of training, a fixed small parameter budget, one that is equal to the size of the final sparse model for inference. We make a distinction between these direct training methods (first block) and compression methods (second and third blocks of Table 6) 11.
+
+Table 6: Representative examples of training methods that yield “sparse” deep CNNs   
+
+<table><tr><td>Method</td><td>Strict parameter budget throughout training and inference</td><td>Granularity of sparsity</td><td>Automatic layer sparsity</td></tr><tr><td>Dynamic Sparse Reparameterization (Ours)</td><td>yes</td><td>non-structured</td><td>yes</td></tr><tr><td>Sparse Evolutionary Training (SET) (Mocanu et al., 2018)</td><td>yes</td><td>non-structured</td><td>no</td></tr><tr><td>Deep Rewiring (DeepR) (Bellec et al., 2017)</td><td>yes</td><td>non-structured</td><td>no</td></tr><tr><td rowspan="2">NN Synthesis Tool (NeST) (Dai et al., 2017; 2018) tf.contrib.model_pruning (Zhu &amp; Gupta,2017)</td><td>no</td><td>non-structured</td><td>yes</td></tr><tr><td>no</td><td>non-structured</td><td>no</td></tr><tr><td>RNN Pruning (Narang et al.,2017)</td><td>no</td><td>non-structured</td><td>no</td></tr><tr><td>Deep Compression (Han et al., 2015)</td><td>no</td><td>non-structured</td><td>no</td></tr><tr><td>Group-wise Brain Damage (Lebedev&amp;Lempitsky,2015)</td><td>no</td><td>channel</td><td>no</td></tr><tr><td>L1-norm Channel Pruning (Li et al., 2016)</td><td>no</td><td>channel</td><td>no</td></tr><tr><td>Structured Sparsity Learning (SSL) (Wen et al., 2016)</td><td>no</td><td>channel/kernel/layer</td><td>yes</td></tr><tr><td>ThiNet (Luo et al., 2017)</td><td>no</td><td>channel</td><td>no</td></tr><tr><td>LASSO-regression Channel Pruning (He et al., 2017)</td><td>no</td><td>channel</td><td>no</td></tr><tr><td>Network Slimming (Liu et al., 2017)</td><td>no</td><td>channel</td><td>yes</td></tr><tr><td>Sparse Structure Selection (SSS) (Huang &amp; Wang,2017)</td><td>no</td><td>layer</td><td>yes</td></tr><tr><td>Principal Filter Analysis (PFA) (Suau et al., 2018)</td><td>no</td><td>channel</td><td>yes/no</td></tr></table>
+
+We provide examples of different categories of methods. This is not a complete list of methods.
+
+This distinction is meaningful in two ways: (a) practically, direct training methods are more memoryefficient on appropriate computing substrate by requiring parameter storage of no more than the final compressed model size; (b) theoretically, these methods, if performing on par with or better than compression methods (as this work suggests), shed light on an important question: whether gross overparameterization is necessary for good generalization performance?
+
+Granularity of sparsity The granularity of sparsity refers to the additional structure imposed on the placement of the non-zero entries of a sparsified parameter tensor. The finest-grained case, namely non-structured, allows each individual weight in a parameter tensor to be zero or non-zero independently. Early compression techniques, e.g. Han et al. (2015), and more recent pruning-based compression methods based thereon, e.g. Zhu & Gupta (2017), are non-structured (second block of Table 6). So are all direct training methods like ours (first block of Table 6).
+
+Non-structured sparsity makes its computations difficult to accelerate on GPUs. To tackle this problem, a class of compression methods, called structured pruning (third block in Table 6), constrain “sparsity” to a much coarser granularity. Typically, pruning is performed to an entire convolution channel, e.g. ThiNet (Luo et al., 2017), even whole layers or residual blocks (Huang & Wang, 2017). This way, the compressed “sparse” model has essentially smaller and/or fewer dense parameter tensors, and computation can thus be accelerated on GPUs the same way as dense neural networks.
+
+These structured compression methods, however, did not make a useful baseline in this work, for the following reasons. First, because they produce dense models, their relevance to our method (non-structured, non-compression) is far more remote than non-structured compression techniques yielding sparse models, for a meaningful comparison. Second, typical structured pruning methods substantially underperformed non-structured ones (see Table 2 for two examples, ThiNet and SSS), and emerging evidence has called into question the fundamental value of structured pruning: Mittal et al. (2018) found that the channel pruning criteria used in a number of state-of-the-art structured pruning methods performed no better than random channel elimination, and Liu et al. (2018) found that fine-tuning in a number of state-of-the-art pruning methods fared no better than direct training of a randomly initialized pruned model which, in the case of channel/layer pruning, is simply a less wide and/or less deep dense model (see Table 2 for comparison of ThiNet and SSS against thin dense).
+
+In addition, we also performed extra experiments in which we constrained our method to perform “structured sparsification” and obtained significantly worse results, see Appendix D.
+
+Predefined versus automatically discovered sparsity levels across layers The last key feature (rightmost column of Table 6) for our classification of methods is whether the sparsity levels of different layers of the network is automatically discovered during training or predefined by manual configuration. The value of automatic sparsification, e.g. ours, is twofold. First, it is conceptually more general because parameter reallocation heuristics can be applied to diverse model architectures, whereas layer-specific configuration has to be cognizant of network architecture, and at times also of the task to learn. Second, it is practically more scalable because it obviates manual configurations of layer-wise sparsity, agnostic of the depth and size of the network, keeping the overhead of hyperparameter tuning constant rather than scaling with model depth/size. In addition to efficiency, we also show in Appendix E extra experiments on how automatic parameter reallocation across layers contributed to its effectiveness.
+
+In conclusion, to the best of our knowledge, our method is unique from all existing ones because it • strictly maintained a fixed parameter footprint throughout the entire course of training, and • automatically discovered layer-wise sparsity levels during training.
+
+As discussed in Appendix C, we benchmarked our direct sparse training methods against the best performing non-structured pruning method (Zhu & Gupta, 2017) known to us. Compression by structured channel-wise pruning, on the other hand, is not better than even the thin dense baseline (Table 2), consistent with recent criticisms (Mittal et al., 2018; Liu et al., 2018).
+
+We asked how our method would perform if it were constrained to training sparse models at a coarser granularity. To answer this question, we performed additional experiments for WRN-28-2 trained on CIFAR10 and Resnet-50 trained on Imagenet, as described in the following.
+
+Consider a weight tensor of a convolution layer, of size $C _ { \mathrm { o u t } } \times C _ { \mathrm { i n } } \times 3 \times 3$ , where $C _ { \mathrm { o u t } }$ and $C _ { \mathrm { i n } }$ are the number of output and input channels, respectively. Our method performed dynamic sparse reparameterization by pruning and reallocating individual weights of the 4-dimensional parameter tensor–the finest granularity. To adapt our procedure to coarse-grain sparsity on groups of parameters, we modified our Algorithm 1 in the following ways:
+
+1. the pruning step now removed entire groups of weights by comparing their $L ^ { 1 }$ -norms with the adaptive threshold;   
+2. the adaptive threshold was updated based on the difference between the target number and the actual number of groups to prune/grow at each step;   
+3. the growth step reallocated groups of weights within and across parameter tensors using the same heuristic (Equation 2).
+
+We show results at kernel-level granularity (i.e. groups are $3 \times 3$ kernels) in Figure 5 and Table 7, for WRN-28-2 on CIFAR10 and Resnet-50 on Imagenet, respectively. We made two observations. First, enforcing kernel-level sparsity leads to significantly worse accuracy compared to unstructured sparsity. Second, at this coarser granularity, our method still outperformed the thin dense baseline model with the same number of parameters.
+
+![](images/e3958a65df44cfadab80fab8ddfdaf24851bc54c5df4c62022b013f7a84b90bc.jpg)  
+Figure 5: Test accuracy for WRN-28-2 trained on CIFAR10 for two variants of dynamic sparse, i.e. kernel-level granularity of sparsity and non-structured (same as dynamic sparse in the main text), as well as the thin dense baseline. Conventions same as in Figure 1a.
+
+Table 7: Test accuracy $\%$ (top-1, top-5) of Resnet-50 on Imagenet for different levels of granularity of sparsity   
+
+<table><tr><td>Final overall sparsity (# Parameters)</td><td>0.8 (7.3M)</td><td>0.9 (5.1M)</td></tr><tr><td>Thin dense</td><td>71.6 [-3.3] 90.3 [-2.1]</td><td>69.4 [-5.5] 89.2 [-3.2]</td></tr><tr><td>Dynamic sparse (kernel granularity)</td><td>72.6 [-2.3] 91.0 [-1.4]</td><td>70.2 [-4.7] 89.8[-2.6]</td></tr><tr><td>Dynamic sparse (non-structured)</td><td>73.3 [-1.6] 92.4[ 0.0]</td><td>71.6 [-3.3] 90.5 [-1.9]</td></tr></table>
+
+Numbers in square brackets are differences from the full dense baseline.
+
+When we further coarsened the granularity of sparsity to channel level (i.e. groups are $C _ { \mathrm { i n } } \times 3 \times 3$ slices that generate output feature maps), our method utterly failed to produce performant models.
+
+# APPENDIX E AUTOMATIC PARAMETER REALLOCATION ACROSS LAYERS ENABLES LEARNING AT EXTREME SPARSITY LEVELS
+
+In order to assess whether and how much our parameter reallocation heuristic (Equation 2) contributed to the effectiveness of our method, we did a set of control experiments in which all free parameter reallocation were constrained to within parameter tensors, i.e. parameter reallocation across layers were disabled, and sparsity stayed constant (uniformly initialized) for each layer.
+
+The results are presented in Figure 6 for LeNet-300-100-10 on MNIST. We found that removing inter-layer parameter allocation yielded worse performance, particularly at extremely high sparsity levels. This suggested that parameter reallocation across the entire model was beneficial to our dynamic reparameterization.
+
+![](images/2cb39471fd583c668e893bb918ad6e1242e1a549bc5211c5b4da4426886d5aee.jpg)  
+Figure 6: Test accuracy for LeNet-300-100-10 on MNIST of dynamic sparse (i.e. Algorithm 1) compared against constrained dynamic sparse for which parameter reallocation occurred only within, but not across, layers.

parse/train/SyevDaVYwr/SyevDaVYwr.md

@@ -0,0 +1,354 @@
+# CONFIDENCE SCORES MAKE INSTANCE-DEPENDENTLABEL-NOISE LEARNING POSSIBLE
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Learning with noisy labels has drawn a lot of attention. In this area, most of recent works only consider class-conditional noise, where the label noise is independent of its input features. This noise model may not be faithful to many real-world applications. Instead, few pioneer works have studied instance-dependent noise, but these methods are limited to strong assumptions on noise models. To alleviate this issue, we introduce confidence-scored instance-dependent noise (CSIDN), where each instance-label pair is associated with a confidence score. The confidence scores are sufficient to estimate the noise functions of each instance with minimal assumptions. Moreover, such scores can be easily and cheaply derived during the construction of the dataset through crowdsourcing or automatic annotation. To handle CSIDN, we design a benchmark algorithm termed instance-level forward correction. Empirical results on synthetic and real-world datasets demonstrate the utility of our proposed method.
+
+# 1 INTRODUCTION
+
+The recent success of deep neural networks has increased the need for high-quality labeled data. However, such a labelling process can be time-consuming and costly. A compromise is to resort to weakly-supervised annotations, using crowdsourcing platforms or trained classifiers that annotate the data automatically. These weakly-supervised annotations tend to be low-quality and noisy, which negatively affects the accuracy of high-capacity models due to memorization effects (Zhang et al., 2017). Thus, learning with noisy labels has often drawn a lot of attention.
+
+Early works on noisy labels studied random classification noise (RCN) for binary classification (Angluin & Laird, 1988; Kearns, 1993). In the RCN model, each instance has its label flipped with a fixed noise rate $\rho \in [ 0 , \frac { 1 } { 2 } )$ . A natural extension of RCN is class-conditional noise (CCN) for multiclass classification (Stempfel & Ralaivola, 2009; Natarajan et al., 2013; Scott et al., 2013; Menon et al., 2015; van Rooyen & Williamson, 2015; Patrini et al., 2016) (Appendix A). In the CCN model, each instance from class $i$ has a fixed probability $\rho _ { i , j }$ of being assigned to class $j$ . Thus, it is possible to encode some similarity information between classes. For example, we can expect that the image of a “dog” is more likely to be erroneously labelled as “cat” than “boat”.
+
+To handle the CCN model, a common method is the loss correction, which aims to correct the prediction or the loss of the classifier using an estimated noise transition matrix (Patrini et al., 2017; Sukhbaatar et al., 2015; Goldberger & Ben-Reuven, 2017; Ma et al., 2018). Another common approach is the label correction, which aims to improve the label quality during training. For example, Reed et al. (2015) introduced a bootstrapping scheme. Similarly, Tanaka et al. (2018) proposed to update the weights of a classifier iteratively using noisy labels, and use the updated classifier to yield more high-quality pseudo-labels for the training set. Although these methods have theoretical guarantees, they are unable to cope with real-world noise, e.g., instance-dependent noise (IDN).
+
+The IDN model considers a more general noise (Manwani & Sastry, 2013; Ghosh et al., 2014; Menon et al., 2016; Cheng et al., 2017; Menon et al., 2018), where the probability that an instance is mislabeled depends on both its class and features. Intuitively, this noise is quite realistic, as poorquality or ambiguous instances are more likely to be mislabeled in real-world datasets. However, it is much more complex to formulate the IDN model, since the probability of a mislabeled instance is a function of not only the label space but also the input space that can be very high dimensional.
+
+Table 1: Comparisons between baselines and our work for handling the IDN model. Rate identifiability denotes whether the transition matrix is identifiable.   
+
+<table><tr><td rowspan=1 colspan=1>Approaches</td><td rowspan=1 colspan=1>Multi-class</td><td rowspan=1 colspan=1>Rate-identifiability</td><td rowspan=1 colspan=1>Unbounded-noise</td></tr><tr><td rowspan=1 colspan=1>Du&amp;Cai(2015)</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>Menon et al. (2018)</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>Bootkrajang&amp; Chaijaruwanich (2018)</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>Cheng et al. (2017)</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Our work</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td></tr></table>
+
+As a result, several pioneer works have considered stronger assumptions on noise functions. However, stronger assumptions tend to restrict the utility of these works (Table 1). For instance, the boundary-consistent noise model considers stronger noise for samples closer to the decision boundary of the Bayesian optimal classifier (Du & Cai, 2015; Menon et al., 2018). However, such a model is restricted to binary and cannot estimate noise functions. Cheng et al. (2017) recently studied a particular case of the IDN model, where noise functions are upper-bounded. Nonetheless, their method is limited to binary classification and has only been tested on small datasets.
+
+Instead of simplifying assumptions on noise functions, we propose to tackle the IDN model from the source, by considering confidence scores to be available for the label of each instance. We term this new setting confidence-scored instance-dependent noise (CSIDN, Figure 1c). The confidence scores denote how likely an instance is to be correctly labeled. Assuming that (i) confidence scores are available for each instance, (ii) transitions probabilities to other classes are independent of the instance conditionally on the assigned label being erroneous and (iii) a set of anchor points is available, we derive an instance-level forward correction algorithm which can fully estimate the transition probability for each instance, and subsequently train a robust classifier with a loss-correction method similarly to Patrini et al. (2017).
+
+It is noted that confidence scores can be easily and cheaply derived during the construction of the dataset. For example, in crowdsourcing platforms, simply counting how many annotators agree on a given instance can give a notion of how confident a label is. Besides, many real-world datasets are automatically annotated using a trained classifier, such as web-scraped datasets (Tong Xiao et al., 2015) and physiological features inferred from medical records (Agarwal et al., 2016). In these cases, the class-probabilities of the labels assigned by the classifier can be seen as confidence scores, provided that the classifier is well calibrated (Guo et al., 2017).
+
+To sum up, we first formulate instance-dependent noise in Section 2.1, and expose its robustness challenge in Section 2.2. Then, we explain our motivation to use confidence scores, and propose the confidence-scored instance-dependent noise (CSIDN) model in Section 2.3. Lastly, to handle this new noise model, we present the first practical algorithm termed instance-level forward correction in Section 3, and validate the proposed algorithm through extensive experiments in Section 4.
+
+# 2 TACKLING INSTANCE-DEPENDENT NOISE FROM THE SOURCE
+
+In this section, we present the IDN model along with the limitations of existing approaches, and introduce the CSIDN model as a tractable instance-dependent noise model.
+
+# 2.1 NOISE MODELS: FROM CLASS-CONDITIONAL TO INSTANCE-DEPENDENT NOISE
+
+We formulate the problem of learning with noisy labels in this section. Let $D$ be the distribution of a pair of random variables $( X , Y ) \in { \mathcal { X } } \times { \mathcal { Y } }$ , where $\boldsymbol { \mathcal { X } } \in \mathbb { R } ^ { d }$ , $\mathcal { Y } = \{ 1 , 2 , \dots , K \}$ and $K$ is the number of classes. In the classification task with noisy labels, we hope to train a classifier while having only access to samples from a noisy distribution $\bar { D }$ of random variables $( X , { \bar { Y } } ) \in { \mathcal { X } } \times { \mathcal { Y } }$ . Given a point $x$ sampled from $X$ , $\bar { Y }$ is derived from the random variable $Y$ via a noise transition matrix $\bar { T ( x ) } = ( T _ { i , j } \bar { ( x ) } ) _ { i , j = 1 } ^ { K } \in [ 0 , 1 ] ^ { K \times K }$ :
+
+$$
+\forall 1 \leq j \leq K , P ( \bar { Y } = j | X = x ) = \sum _ { i = 1 } ^ { K } T _ { i , j } ( x ) P ( Y = i | X = x ) .
+$$
+
+![](images/7afb187ee3358601c0112a1211bee06efbe15a18b8956ddda771e16703cb59ee.jpg)  
+Figure 1: Illustration of different noise models. Each color represents an observed class $\bar { y }$ : circles indicate ${ \bar { y } } = y$ , while crosses indicate $\bar { y } \ne y$ . The size of each point represents the confidence scores in the label $\bar { y }$ : the bigger the point is, the more confident it is. In the CCN model, the noise function only depends on the label of each instance. In the IDN and CSIDN models, the noise function depends on the observed instance $x$ . To illustrate the IDN model, we show a special case called boundary-consistent noise, i.e., points that lie close to the decision boundary are more likely to be mislabelled. Note the CSIDN model varies from the IDN model via confidence scores (Section 2.3).
+
+Each noise function $T _ { i , j } : \mathcal { X } \mapsto [ 0 , 1 ]$ is defined as $T _ { i , j } ( x ) = P ( \bar { Y } = j | Y = i , X = x )$ . In the class-conditional noise (CNN) model (Figure 1a), the transition matrix does not depend on the instance $x$ and the noise is entirely characterized by the $K ^ { 2 }$ constants $T _ { i , j }$ . However, in the instancedependent noise (IDN) model (Figure 1b), the transition matrix depends on the actual instance. This tremendously complicates the problem, as the noise is now characterized by $K ^ { 2 }$ functions over the latent space $\mathcal { X }$ , which can be very high dimensional (e.g., $d \sim 1 0 ^ { 4 } – 1 0 ^ { 6 }$ for an object recognition dataset).
+
+# 2.2 CHALLENGES FROM INSTANCE-DEPENDENT NOISE
+
+Limitation of existing CCN methods. Due to the complexity of the IDN model, most recent works in learning with noisy labels have focused on the CCN model (Figure 1a), and the CCN model can be seen as a simplified IDN model (Figure 1b) free of feature information.
+
+In addition to loss correction and label correction mentioned before, another method for the CCN model is sample selection, which aims to find reliable samples during training, such as the smallloss approaches (Jiang et al., 2018; Han et al., 2018). Inspired by the memorization in deep learning (Arpit et al., 2017), those methods first run a standard classifier on a noisy dataset, then select the small-loss samples for reliable training.
+
+However, all approaches cannot handle the IDN model directly. Specifically, loss correction considers the noise model to be characterized by a fixed transition matrix, which does not include any instance-level information. Meanwhile, label correction is vulnerable to the IDN model, since the classifier will be much weaker on noisy regions and labels corrected by the current prediction would likely be erroneous. Similarly, sample selection is easily affected by the IDN model.
+
+For example, in the small-loss approaches, instance-dependent noise functions can leave partial regions of the input space clean and other regions very noisy (e.g., in an object recognition dataset, poor-quality pictures will tend to receive more noisy labels than high-quality ones). Since clean regions will tend to receive smaller losses than noisy regions, the small-loss approaches, which only trains on points with the smallest-losses, will focus on clean regions and neglect harder noisy regions. Then, since the distribution of clean regions will subsequently be different from the global distribution, this will introduce a covariate-shift (Shimodaira, 2000), which greatly degrades performances. Moreover, it is hard to use importance reweighting (Sugiyama et al., 2007) for alleviate the issue, since importance reweighting would require estimating the clean posterior probability that is intractable for the IDN model.
+
+To validate this fact, we generate a 3-class distribution of concentric circles (cf. Figure 2a), with $\forall ( x , y ) \in \mathbb { R } ^ { 2 } \times \{ 1 , 2 , 3 \}$ , $\begin{array} { r } { P ( \bar { y } \neq y | x ) = \frac { 1 } { 2 } \left( \frac { w \cdot x } { \| w \| \| x \| } + 1 \right) } \end{array}$ with $w = ( 0 , 1 )$ (cf. Figure 2b). We then train a network on the top $R ( T )$ small-loss instances at each epoch $T$ based on the losses of the previous epoch, with $R ( T )$ decreasing in $T$ as described in Han et al. (2018). Figure 2c shows the density of the top $5 0 \%$ small-loss instances selected after 10 epochs: since noisy regions are associated to higher losses, the network eventually tends to select instances from the clean region and neglect the noisy region. This leads to covariate-shift, which is associated with decreased performances (Shimodaira, 2000).
+
+![](images/50adae055b1e41d3db4403c2fc38f99c340f916125eb84994d44527331c19db5.jpg)  
+Figure 2: The limitation of the small-loss approaches in the IDN model. (a) Clean distribution. (b) instance-dependent noise in the direction $w = ( 0 , 1 )$ with an average corruption rate of $40 \%$ : points towards the upper region are more likely to be corrupted than points towards the bottom region. (c) Density map of the instances selected by a small-loss approach at epoch 10. The sample selection gets biased towards clean regions. Since the clean and noisy regions have different distributions, selecting most instances from clean regions creates a covariate-shift between the training and test distributions, which can greatly degrades performances.
+
+Limitation of pioneer IDN methods. The main challenge of the IDN model is the wide range of possible noise functions included in its formulation. Since each $T _ { i , j } ( \cdot )$ is a function of the highdimensional input space $\mathcal { X }$ , it is challenging for a model to be flexible enough to fit any real-world noise function while being trainable on corrupted datasets, let alone derive theoretical results. Instead, various recent works have considered stronger assumptions on noise functions.
+
+For instance, boundary-consistent noise (BCN), first introduced by (Du & Cai, 2015) and generalized in Menon et al. (2018), considers stronger noise for samples closer to the decision boundary of the Bayesian optimal classifier. This is a reasonable model for noise from human annotators, since “harder” instances (i.e., instances closer to the decision boundary) are more likely to be corrupted. Moreover, it is simple enough to derive some theoretical guarantees, as done in Menon et al. (2018). Additionally, an extension of the BCN model was studied in Bootkrajang & Chaijaruwanich (2018), where the noise function is a Gaussian mixture of the distance to the Bayesian optimal boundary. However, the BCN model and its extension are restricted to binary classification, and their geometry-based assumption becomes difficult to fathom for high-dimensional input spaces.
+
+Furthermore, Cheng et al. (2017) recently studied a particular case of the IDN model, where the probabilities that the true labels of samples flip into corrupted ones have upper bounds. They proposed a method based on distilled samples, where noisy labels agree with the optimal Bayesian classifier on the clean distribution. However, their method is limited to binary classification and has only been tested on small UCI datasets. Table 1 summarizes the characteristics of those approaches.
+
+# 2.3 CONFIDENCE-SCORED INSTANCE-DEPENDENT NOISE
+
+Instead of simplifying assumptions on noise functions, we propose to tackle the IDN model from the source. Namely, we consider that, for each instance, we have access to a measure of confidence in the assigned label. As most of noisy datasets arise from crowdsourcing or automatic annotation, such confidence scores can be easily derived during the dataset construction, often with no extra cost. This allows for a good approximation of noise functions with weaker assumptions.
+
+Before introducing our proposed noise model confidence-scored instance-dependent noise (CSIDN, Figure 1c), we first define what are the confidence scores, and explain why the confidence scores are available in real-world applications.
+
+Definition of confidence scores. For any data point $( x , { \bar { y } } )$ sampled from the joint distribution $( X , { \bar { Y } } )$ , we define the confidence score $r _ { x }$ as follows.
+
+$$
+r _ { x } = P ( Y = \bar { y } | \bar { Y } = \bar { y } , X = x ) .
+$$
+
+Namely, the probability that the assigned label is correct.
+
+Availability of confidence scores. Our rationale is that in tasks involving instance-dependent noise, the confidence information can be easily derived with no extra cost.
+
+Firstly, in crowdsourcing platforms, when multiple workers manually annotate datasets, an aggregation step is often took to aggregate answers of different workers for each instance (e.g., majority vote). An estimation of $r _ { x }$ could then be derived by taking the ratio of votes for the assigned label on the total number of workers. Moreover, since this estimation would of course be less reliable as the number of workers decreases, an alternative could be to directly ask workers for self-reported confidence scores of their responses (Cosmides & Tooby, 1996; Oyama et al., 2013).
+
+Secondly, the confidence information can also be available in automatic annotation via a softmax output layer of deep neural networks. This layer outputs an estimation of the probability that each class is the true label: when a model outputs a given class with probability 0.9, we expect the predicted class to be true 9 times out of 10 on average. A model that estimates the accurate probability is well-calibrated. Therefore, in the case of labels generated by a well-calibrated model, the softmax probability of the assigned label can be directly interpreted as a confidence measure that the label is correct. Even though Guo et al. (2017) showed that recent deep neural networks are not usually well-calibrated (whereas early shallower networks were, as shown in Niculescu-Mizil & Caruana (2005)), model calibration can be achieved in a relatively straightforward way at the validation time, e.g., using temperature scaling (Section 4.2 in Guo et al. (2017)).
+
+CSIDN: a tractable instance-dependent noise model. Recall the intrinsic difficulty of the IDN model: to fully characterize this noise, one would need to estimate $K ^ { 2 }$ functions $T _ { i , j } ( \cdot )$ over the input space $\mathcal { X }$ . This is of course intractable with a finite noisy dataset. This is why pioneer solutions to the IDN model have been so far limited by very strong assumptions.
+
+However, considering additional confidence scores, one can wonder whether such information would make the IDN model tractable with less restrictive assumptions. Hence, we introduce a new and tractable instance-dependent noise model: confidence-scored instance-dependent noise (CSIDN, Figure 1c). In this noise model, the training data takes the form ${ \cal S } : = \{ ( x _ { i } , \bar { y } _ { i } , r _ { x _ { i } } ) , i =$ $1 , \ldots , N \}$ , where $\{ ( x _ { i } , { \bar { y } } _ { i } ) \} _ { i }$ i.i.d. ∼ $\bar { D }$ and $r _ { x _ { i } } = P ( Y = \bar { y } _ { i } | \bar { Y } = \bar { y } _ { i } , X = x _ { i } ) $ is the previously defined confidence scores in the assigned label of a given instance (Eq. (2)). The confidence information $r _ { x }$ is decisive for robustness to instance-dependent noise, as it provides a proxy for the noise functions $T _ { i , j }$ of the training data that are often intractable otherwise.
+
+# 3 BENCHMARK SOLUTION FOR HANDLING THE CSIDN MODEL
+
+To tackle the CSIDN model, we propose a benchmark solution. Inspired by forward correction (Patrini et al., 2017) for the CCN model, we want to correct each prediction $P ( { \bar { y } } | x )$ with the noise transition matrix $T ( x )$ . However, the transition matrix for the CSIDN model is instance-dependent, and has to be estimated for each instance $x$ . We term our solution instance-level forward correction.
+
+# 3.1 ESTIMATING INSTANCE-DEPENDENT TRANSITION MATRIX
+
+Using the confidence scores, we will first estimate the diagonal terms $( T _ { i , i } ( \cdot ) ) _ { i = 1 } ^ { K }$ of the transition matrix, and then estimate the non-diagonal ones.
+
+Diagonal terms. The diagonal terms of the transition matrix correspond to the probabilities that assigned labels are equal to true labels. However, the confidence scores available are only relevant
+
+to the class corresponding to the observed label. Therefore, we need to proceed differently whether the confidence scores are available for the considered class or not.
+
+First, note that for each sample $( x , \bar { y } , r _ { x } ) \in S _ { i } : = \{ ( x , \bar { y } , r _ { x } ) \in S | \bar { y } = i \} ,$ , $T _ { i , i } ( x )$ can be derived for the most part from the confidence scores alone:
+
+$$
+\begin{array} { r l } & { \forall ( x , \bar { y } , r _ { x } ) \in S _ { i } , \ T _ { i , i } ( x ) = P ( \bar { Y } = i | Y = i , X = x ) } \\ & { \qquad = P ( Y = i | \bar { Y } = i , X = x ) \frac { P ( \bar { Y } = i | X = x ) } { P ( Y = i | X = x ) } } \\ & { \qquad = r _ { x } \ \beta _ { i } ( x ) , } \end{array}
+$$
+
+$\begin{array} { r } { \beta _ { i } ( x ) = \frac { P ( \bar { Y } = i | X = x ) } { P ( Y = i | X = x ) } } \end{array}$
+
+In practice, we use an iterative procedure to estimate in turn $\beta _ { i } ( \cdot )$ and $T _ { i , i } ( \cdot )$ (see Section 3.2 for details). Then, for the rest of samples $( x , \bar { y } , r _ { x } ) \in S \backslash S _ { i }$ , $r _ { x }$ does not give any direct information on $T _ { i , i } ( \cdot )$ . Hence, we simply set each function $T _ { i , i } ( \cdot )$ as its empirical mean $\mu _ { i }$ estimated using samples from $S _ { i }$ at the current epoch:
+
+$$
+\forall ( x , y , r _ { x } ) \in S \backslash S _ { i } , \ \hat { T } _ { i , i } ( x ) = \frac { 1 } { | S _ { i } | } \sum _ { ( x ^ { \prime } , \bar { y } ^ { \prime } , r _ { x } ^ { \prime } ) \in S _ { i } } T _ { i , i } ( x ^ { \prime } ) = \mu _ { i } ,
+$$
+
+where $| S |$ denotes the cardinality of $S$ .
+
+Non-diagonal terms. For non-diagonal terms, we have:
+
+$$
+\begin{array} { r l } & { \forall i \neq j , \forall x \in \mathcal { X } , T _ { i , j } ( x ) = P ( \hat { Y } = j | Y = i , X = x ) } \\ & { \qquad = P ( \hat { Y } = j , \hat { Y } \neq i | Y = i , X = x ) } \\ & { \qquad = P ( \hat { Y } = j | \hat { Y } \neq i , Y = i , X = x ) P ( \hat { Y } \neq i | Y = i , X = x ) } \\ & { \qquad = \alpha _ { i , j } ( x ) ( 1 - T _ { i , i } ( x ) ) , } \end{array}
+$$
+
+where $\alpha _ { i , j } ( x ) = P ( \bar { Y } = j | \bar { Y } \neq i , Y = i , X = x )$ .
+
+In Eq. (4), $\alpha _ { i , j } ( x )$ refers to the probability that an instance $x$ with true label $i$ has an observed label $j$ , once we know that the observed label is different from the true one. Then, a reasonable assumption is that $\forall i \neq j , \forall x \in \mathcal { X } , \alpha _ { i , j } ( x ) = \alpha _ { i , j }$ : conditionally on the observed label being erroneous, the class transitions are not influenced by the instance $x$ . In other words, the dependence in $x$ of the noise function only impacts the “magnitude” of the noise and not the class transitions.
+
+To illustrate this assumption, consider a crowdsourcing task of object recognition with adjacent classes which annotators can only differentiate with details that can be more or less visible depending on the instance. For example, objects from a given class may have distinctive traits, but those can be more or less visible in the pictures. When those traits are present, the annotators can confidently predict the right class. Otherwise, they will make errors towards adjacent classes. In this case, the probability that the assigned label is wrong highly depends the instance (with distinctive traits being visible or not). Nonetheless, conditionally on the instance being corrupted, i.e., because those traits were not visible enough on the image, the transition probabilities to the adjacent classes are not influenced by the instance itself.
+
+With the previous assumption, we obtain $\forall i \neq j , \forall x \in \mathcal { X } , T _ { i , j } ( x ) = \alpha _ { i , j } ( 1 - T _ { i , i } ( x ) )$ with $\alpha _ { i , j } \in$ $[ 0 , 1 ]$ . This allows us to estimate the $K ( K { - } 1 )$ constants $( \alpha _ { i , j } ) _ { i \neq j }$ once, and derive the non-diagonal noise functions of $T ( x )$ directly from our estimates of the diagonal noise functions (Eq. (5)).
+
+3.2 OVERALL ALGORITHM: INSTANCE-LEVEL FORWARD CORRECTION
+
+Estimating $T _ { i , i }$ and $\beta _ { i }$ . To train a classifier $h$ with the instance-level forward correction method, we need to estimate both $T _ { i , i } ( x )$ and $\begin{array} { r } { \beta _ { i } ( x ) = \frac { P ( \bar { Y } = i | X = x ) } { P ( Y = i | X = x ) } } \end{array}$ from Eq. (3), for all $x \in S _ { i }$ . Firstly, the noisy posterior $P ( \bar { Y } = i \vert X = x )$ can be easily estimated by training a naive classifier on the noisy dataset. Secondly, the true posterior $P ( Y = i \vert X = x )$ can be estimated using the output of the classifier $h ( x ) = \hat { P } ( Y = i \vert X = x )$ at the previous epoch.
+
+Therefore, we iteratively update $\hat { \beta }$ and $\hat { T }$ with the following steps: 1) $\forall x \in { \mathcal { X } }$ , initialize $\hat { \beta } _ { i } ( x ) = 1$ and train a naive classifier $h _ { \mathrm { n o i s y } }$ on the noisy data $\bar { D }$ to obtain $h _ { \mathrm { n o i s y } } ( x ) = \hat { P } ( \bar { Y } | X = x )$ . 2) $\forall i \in [ 1 , K ]$ , for each sample $( x , { \bar { y } } , r _ { x } ) \in S _ { i }$ , compute $\hat { T } _ { i , i } ( x ) = r _ { x } \hat { \beta } _ { i } ( x )$ and train classifier $h$ for one epoch. 3) $\forall i \in [ 1 , K ]$ , for each sample $( x , \bar { y } , r _ { x } ) \in S _ { i }$ , update $\begin{array} { r } { \hat { \beta } _ { i } ( x ) = \frac { h _ { \mathrm { n o i s y } } ( x ) _ { i } } { h ( x ) _ { i } } } \end{array}$ . Then, we repeat steps 2) and 3) through training. In this way, for every epoch, each function $T _ { i , i } ( \cdot )$ is estimated for the samples from $S _ { i }$ . Lastly, for the rest of samples with noisy label $j \neq i , T _ { i , i } ( \cdot )$ is estimated at each epoch using Eq. (4):
+
+$$
+\forall ( x , y , r _ { x } ) \in S \backslash S _ { i } , \ \hat { T } _ { i , i } ( x ) = \frac { 1 } { | S _ { i } | } \sum _ { ( x ^ { \prime } , \bar { y } ^ { \prime } , r _ { x } ^ { \prime } ) \in S _ { i } } r _ { x } ^ { \prime } \hat { \beta } _ { i } ( x ^ { \prime } ) = \mu _ { i } .
+$$
+
+Computing $\alpha _ { i , j }$ . The computation of $\alpha _ { i , j }$ boils down to approximating non-diagonal terms of the transition matrix in the CCN model. As $\forall i \neq j , \forall x \in \mathcal { X }$ , $\bar { T _ { i , j } } ( x ) = \alpha _ { i , j } \bar { ( 1 - T _ { i , i } ( x ) ) }$ , we have:
+
+$$
+\mathbb { E } _ { x } \left[ T _ { i , j } ( x ) \right] = \alpha _ { i , j } \left( 1 - \mathbb { E } _ { x } \left[ T _ { i , i } ( x ) \right] \right) \Leftrightarrow \alpha _ { i , j } = \frac { \mathbb { E } _ { x } \left[ T _ { i , j } ( x ) \right] } { 1 - \mathbb { E } _ { x } \left[ T _ { i , i } ( x ) \right] } .
+$$
+
+A simple and reliable way is to use anchor points, i.e., points for which we can know the true class almost surely. These points may be directly available when some training data has been curated, or they can be identified either theoretically as in Liu & Tao (2015) or heuristically as in Patrini et al. (2017). Having $S _ { i } ^ { * } : = \{ ( x , \bar { y } , r _ { x } ) \in S \dot { | } P ( Y = i | X = x ) \approx 1 \}$ a set of class $i$ anchor points, we simply need compute:
+
+$$
+\forall ( x , \bar { y } , r _ { x } ) \in S _ { i } ^ { * } , \forall j \neq i , T _ { i , i } ( x ) = r _ { x } P ( \bar { Y } = i | X = x ) \mathrm { ~ a n d ~ } T _ { i , j } ( x ) = P ( \bar { Y } = j | X = x ) .
+$$
+
+Two noisy posteriors can be estimated using the same classifier $h _ { \mathrm { n o i s y } }$ trained on the noisy distribution $h _ { \mathrm { n o i s y } } ( x ) = \hat { P } ( \bar { Y } | X = x )$ aforementioned. Thus, $\alpha _ { i , j }$ can be estimated as follows:
+
+$$
+\forall 1 \leq i , j \leq K , j \neq i , \alpha _ { i , j } = \frac { \frac { 1 } { | S _ { i } ^ { * } | } \displaystyle \sum _ { ( x , \bar { y } , r _ { x } ) \in S _ { i } ^ { * } } h _ { \sf n o i s y } ( x ) _ { j } } { 1 - \frac { 1 } { | S _ { i } ^ { * } | } \displaystyle \sum _ { ( x , \bar { y } , r _ { x } ) \in S _ { i } ^ { * } } r _ { x } h _ { \sf n o i s y } ( x ) _ { i } } .
+$$
+
+Summary of the training procedure. Given samples $S$ and $K$ sets of anchor points $( S _ { i } ^ { * } ) _ { i = 1 } ^ { K }$ , we want to train a classifier $h ( \cdot )$ equipped with a loss . For any loss $l : y , \hat { y } \mapsto l ( y , \hat { y } )$ , we define the $T$ -corrected loss as $l _ { T } : y , \hat { y } \mapsto l ( y , T \hat { y } )$ . The overall procedure is in Algorithm 1 (Appendix C).
+
+# 4 EXPERIMENTS
+
+We compare our instance-level forward correction (ILFC) method with four representative baselines: forward correction (FC) (Patrini et al., 2017), mean absolute error (MAE) (Ghosh et al., 2017), $L _ { q }$ - norm (LQ) (Zhang & Sabuncu, 2018) and $^ { c o }$ -teaching (CT) (Han et al., 2018). Details are shown in Appendix D. Note that the pioneer IDN methods cannot work for multi-class cases.
+
+# 4.1 SYNTHETIC DATASET
+
+Generation process. We generate a synthetic dataset (Appendix E) consisting in three classes of concentric circles (Figure 6a). We then apply the following instance-dependent noise to each label: $\begin{array} { r } { P ( \bar { Y } \neq Y | X = x ) = \rho \left( \frac { w \cdot x } { \| w \| \| x \| } + 1 \right) / 2 } \end{array}$ with $w = ( 0 , 1 )$ and $\rho$ controlling the mean noise rate. If corrupted, each label is flipped to another class uniformly.
+
+Empirical results. Figure 3 shows the test accuracy of different methods on the synthetic dataset. Each experiment is repeated 5 times and we plot the confidence intervals of each curve. On low-level noise, all methods show good performances (Figure 3a). On mild-level noise, both Co-teaching and ILFC show good performances and outperform other baselines (Figure 3b). On high-level noise, the performance of all the baselines collapse, whereas ILFC constantly maintains good performances (Figures 3c and 3d). More experiments are shown in Appendix B and F.
+
+![](images/42892105c57033420bd847ee05651166407e1c98941ded80a9f3229d3e4d5fd8.jpg)  
+Figure 3: The test accuracy on synthetic datasets with different levels of IDN noise.
+
+![](images/feac86cd47140d0d778a7cf60d1baa990b5a96a01beabb548e35fb12a8debd9f.jpg)  
+Figure 4: The test accuracy on real-world datasets with different levels of IDN noise.
+
+# 4.2 REAL-WORLD DATASET
+
+Generation process. In order to corrupt labels from clean datasets such as SVHN and CIFAR10, we adopt the following procedure: (1) train a classifier $h : x \mapsto \sigma ( g ( x ) )$ on a small subset of the clean dataset; (2) using a small validation set, calibrate the classifier by selecting the temperature $t$ that maximizes the expected calibration error as in Guo et al. (2017); (3) for each instance $x$ , set: ${ \bar { y } } = \operatorname { a r g m a x } _ { i }$ $h _ { t } ( x ) _ { i }$ and $r _ { x } = \operatorname* { m a x } _ { i } h _ { t } ( x ) _ { i }$ . With this process, we attempt to emulate the construction of a real-world dataset (Appendix G).
+
+Empirical results. Figures 4a and 4b show the test accuracy on SVHN with $2 5 \%$ and $4 5 \%$ instance-dependent noise, respectively. We can clearly observe that, on both low-level and highlevel noise, ILFC shows good performances with a fast convergence rate, and outperforms other baselines. Figures $_ \mathrm { 4 c }$ and 4d show the test accuracy on CIFAR10 with $2 5 \%$ and $4 5 \%$ instancedependent noise, respectively. On low-level noise, all methods show good performances. However, on high-level noise, ILFC shows a fast convergence rate and outperforms other baselines.
+
+# 5 CONCLUSION
+
+In this paper, we give an overview of label-noise learning from class-conditional noise (easier) to instance-dependent noise (harder). We explain why existing approaches cannot handle instancedependent noise well, and try to address this challenge via confidence scores. Thus, we formally propose the confidence-scored instance-dependent noise (CSIDN) model. To tackle the CSIDN model, we design a practical algorithm termed instance-level forward correction (ILFC). Our ILFC method robustly outperforms existing methods, especially in the case of high-level noise. In future works, we would like to extend label correction and sample selection approaches with the confidence scores from the CSIDN model.
+
+# REFERENCES
+
+Vibhu Agarwal, Tanya Podchiyska, Juan M Banda, Veena Goel, Tiffany I Leung, Evan P Minty, Timothy E Sweeney, Elsie Gyang, and Nigam H Shah. Learning statistical models of phenotypes using noisy labeled training data. Journal of the American Medical Informatics Association, 23 (6):1166–1173, 2016.
+
+Dana Angluin and Philip Laird. Learning from noisy examples. Machine Learning, 2(4):343–370, 1988.
+
+Devansh Arpit, Stanisław Jastrzebski, Nicolas Ballas, David Krueger, Emmanuel Bengio, Maxinder S Kanwal, Tegan Maharaj, Asja Fischer, Aaron Courville, Yoshua Bengio, et al. A closer look at memorization in deep networks. In ICML, 2017.
+
+Jakramate Bootkrajang and Jeerayut Chaijaruwanich. Towards instance-dependent label noisetolerant classification: a probabilistic approach. Pattern Analysis and Applications, pp. 1–17, 2018.
+
+Steve Branson, Grant Van Horn, and Pietro Perona. Lean crowdsourcing: Combining humans and machines in an online system. In CVPR, 2017.
+
+Nontawat Charoenphakdee, Jongyeong Lee, and Masashi Sugiyama. On Symmetric Losses for Learning from Corrupted Labels. ICML, 2019.
+
+Jiacheng Cheng, Tongliang Liu, Kotagiri Ramamohanarao, and Dacheng Tao. Learning with bounded instance-and label-dependent label noise. stat, 1050:12, 2017.
+
+Leda Cosmides and John Tooby. Are humans good intuitive statisticians after all? rethinking some conclusions from the literature on judgment under uncertainty. Cognition, 58(1):1–73, 1996.
+
+Jun Du and Zhihua Cai. Modelling class noise with symmetric and asymmetric distributions. In AAAI, 2015.
+
+Aritra Ghosh, Naresh Manwani, and P S. Sastry. Making risk minimization tolerant to label noise. Neurocomputing, 160, 2014.
+
+Aritra Ghosh, Himanshu Kumar, and PS Sastry. Robust loss functions under label noise for deep neural networks. In AAAI, 2017.
+
+Jacob Goldberger and Ehud Ben-Reuven. Training deep neural-networks using a noise adaptation layer. In ICLR, 2017.
+
+Melody Y Guan, Varun Gulshan, Andrew M Dai, and Geoffrey E Hinton. Who said what: Modeling individual labelers improves classification. In AAAI, 2018.
+
+Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q Weinberger. On calibration of modern neural networks. In ICML, 2017.
+
+Bo Han, Quanming Yao, Xingrui Yu, Gang Niu, Miao Xu, Weihua Hu, Ivor Tsang, and Masashi Sugiyama. Co-teaching: Robust training of deep neural networks with extremely noisy labels. In NeurIPS, 2018.
+
+Takashi Ishida, Gang Niu, and Masashi Sugiyama. Binary classification from positive-confidence data. In NeurIPS, 2018.
+
+Lu Jiang, Zhengyuan Zhou, Thomas Leung, Li-Jia Li, and Li Fei-Fei. Mentornet: Learning datadriven curriculum for very deep neural networks on corrupted labels. In ICML, 2018.
+
+Michael Kearns. Efficient noise-tolerant learning from statistical queries. Proceedings of the twentyfifth annual ACM symposium on Theory of computing - STOC 93, 1993.
+
+Ashish Khetan, Zachary C. Lipton, and Anima Anandkumar. Learning from noisy singly-labeled data. In ICLR, 2018.
+
+Samuli Laine and Timo Aila. Temporal Ensembling for Semi-Supervised Learning. ICLR, 2017.
+
+Tongliang Liu and Dacheng Tao. Classification with noisy labels by importance reweighting. IEEE Transactions on pattern analysis and machine intelligence, 38(3):447–461, 2015.
+
+Xingjun Ma, Yisen Wang, Michael E. Houle, Shuo Zhou, Sarah Erfani, Shutao Xia, Sudanthi Wijewickrema, and James Bailey. Dimensionality-driven learning with noisy labels. In ICML, 2018.
+
+Naresh Manwani and P. S. Sastry. Noise tolerance under risk minimization. IEEE Transactions on Cybernetics, 43:1146–1151, 2013.
+
+Hamed Masnadi-shirazi and Nuno Vasconcelos. On the Design of Loss Functions for Classification: theory, robustness to outliers, and SavageBoost. In NeurIPS. 2009.
+
+Aditya Menon, Brendan Van Rooyen, Cheng Soon Ong, and Bob Williamson. Learning from corrupted binary labels via class-probability estimation. In ICML, pp. 125–134, 2015.
+
+Aditya Krishna Menon, Brendan Van Rooyen, and Nagarajan Natarajan. Learning from binary labels with instance-dependent corruption. arXiv preprint arXiv:1605.00751, 2016.
+
+Aditya Krishna Menon, Brendan van Rooyen, and Nagarajan Natarajan. Learning from binary labels with instance-dependent noise. Machine Learning, 107(8-10):1561–1595, September 2018.
+
+Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence, 41(8):1979–1993, 2018.
+
+Nagarajan Natarajan, Inderjit S Dhillon, Pradeep K Ravikumar, and Ambuj Tewari. Learning with Noisy Labels. In NeurIPS. 2013.
+
+Alexandru Niculescu-Mizil and Rich Caruana. Predicting good probabilities with supervised learning. In ICML, 2005.
+
+Satoshi Oyama, Yukino Baba, Yuko Sakurai, and Hisashi Kashima. Accurate integration of crowdsourced labels using workers’ self-reported confidence scores. In IJCAI, 2013.
+
+Giorgio Patrini, Frank Nielsen, Richard Nock, and Marcello Carioni. Loss factorization, weakly supervised learning and label noise robustness. In ICML, 2016.
+
+Giorgio Patrini, Alessandro Rozza, Aditya Krishna Menon, Richard Nock, and Lizhen Qu. Making deep neural networks robust to label noise: A loss correction approach. In CVPR, 2017.
+
+Vikas C Raykar, Shipeng Yu, Linda H Zhao, Anna Jerebko, Charles Florin, Gerardo Hermosillo Valadez, Luca Bogoni, and Linda Moy. Supervised learning from multiple experts: whom to trust when everyone lies a bit. In ICML, 2009.
+
+Scott Reed, Honglak Lee, Dragomir Anguelov, Christian Szegedy, Dumitru Erhan, and Andrew Rabinovich. Training deep neural networks on noisy labels with bootstrapping. ICLR, 2015.
+
+Clayton Scott, Gilles Blanchard, and Gregory Handy. Classification with asymmetric label noise: Consistency and maximal denoising. In COLT, pp. 489–511, 2013.
+
+Yanyao Shen and Sujay Sanghavi. Learning with bad training data via iterative trimmed loss minimization. In ICML, 2019.
+
+Hidetoshi Shimodaira. Improving predictive inference under covariate shift by weighting the loglikelihood function. Journal of statistical planning and inference, 90(2):227–244, 2000.
+
+Rion Snow, Brendan O’Connor, Daniel Jurafsky, and Andrew Ng. Cheap and fast – but is it good? evaluating non-expert annotations for natural language tasks. In EMNLP, 2008.
+
+Guillaume Stempfel and Liva Ralaivola. Learning SVMs from sloppily labeled data. In International Conference on Artificial Neural Networks, pp. 884–893, 2009.
+
+Masashi Sugiyama, Matthias Krauledat, and Klaus-Robert MA˜ zller. Covariate shift adaptation by ˇ importance weighted cross validation. Journal of Machine Learning Research, 8(May):985–1005, 2007.
+
+Sainbayar Sukhbaatar, Joan Bruna, Manohar Paluri, Lubomir Bourdev, and Rob Fergus. Training convolutional networks with noisy labels. ICLR workshop, 2015.   
+Daiki Tanaka, Daiki Ikami, Toshihiko Yamasaki, and Kiyoharu Aizawa. Joint optimization framework for learning with noisy labels. In CVPR, 2018.   
+Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In NeurIPS, 2017.   
+Tong Xiao, Tian Xia, Yi Yang, Chang Huang, and Xiaogang Wang. Learning from massive noisy labeled data for image classification. In CVPR, 2015.   
+Brendan van Rooyen and Robert C. Williamson. Learning in the Presence of Corruption. arXiv e-prints, art. arXiv:1504.00091, Mar 2015.   
+Yan Yan, Romer Rosales, Glenn Fung, Mark Schmidt, Gerardo Hermosillo, Luca Bogoni, Linda ´ Moy, and Jennifer Dy. Modeling annotator expertise: Learning when everybody knows a bit of something. In AISTATS, 2010.   
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In ICLR, 2017.   
+Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. ICLR, 2018.   
+Zhilu Zhang and Mert Sabuncu. Generalized Cross Entropy Loss for Training Deep Neural Networks with Noisy Labels. In NeurIPS. 2018.
+
+# A RELATED WORKS
+
+Besides the works aforementioned, we survey other approaches to learning with noisy labels.
+
+Robust losses. Various approaches propose to use a provably robust loss function in the learning process. In the case of class-dependent label noise, Natarajan et al. (2013) constructed an unbiased estimator of any loss function under the noisy distribution. Masnadi-shirazi & Vasconcelos (2009) introduced a robust non-convex loss. Recently, works on symmetric losses showed that such loss offer theoretical robustness results to various types of noise (Ghosh et al., 2017; Charoenphakdee et al., 2019). Motivated by the robustness to noise of the mean absolute error loss (MAE) shown in Ghosh et al. (2017), Zhang & Sabuncu (2018) introduced generalized cross entropy loss that allows for a trade-off between the efficient learning properties of the CCE loss and the noise-robustness of MAE. Shen & Sanghavi (2019) introduced a trimmed loss with an iterative minimization process that allows for theoretical guarantees in the simpler setting of generalized linear models.
+
+Annotator-level modelling. Another recent line of related works attempts to model labels and worker’s quality directly during the crowdsourcing annotation process, in order to produce more accurate labels efficiently. Branson et al. (2017) modeled the annotators’ skill and instances difficulty while incrementally training a computer vision model during the annotation process, effectively reducing the time burden of the annotation process as well as the error rate in the assigned labels. Guan et al. (2018) modeled each annotator individually in order to better aggregate labels based on each worker’s skill and area of expertise. Khetan et al. (2018) introduced a method that allows to learn each workers’ skill even when each example is only annotated once, by jointly modelling the assigned labels and the workers during the annotation process.
+
+Learning with multiple noisy labels. A closely related setting is learning from multiple noisy labels, where the aim is to predict an unknown ground-truth label from $( X , ( Y ^ { \bar { j } } ) _ { j } )$ , each $Y ^ { j }$ referring to a noisy annotation. This setting can arise for example from crowdsourcing tasks; Snow et al. (2008) showed that using multiple non-expert annotators to train a classifier can be as effective as using gold standard annotations from experts. In Raykar et al. (2009), the authors derive a Bayesian approach to jointly learn the expertise of each annotator, the actual true label and the classifier. Yan et al. (2010) extends this Bayesian approach by considering that each annotator’s expertise varies across the input space. This setting differs from ours as it takes place before the aggregation of multiple annotations, which, for CSIDN, is only a way among others to obtain a confidence score for each noisy label.
+
+Explicit/implicit regularizers. Recently, several other regularization techniques have shown good robustness in weakly-supervised settings. Temporal Ensembling (TE) (Laine & Aila, 2017) method labels some additional unlabeled instances using a consensus of predictions from models from previous epochs and with different regularizations and input augmentation conditions. Mean-teacher (MT) (Tarvainen & Valpola, 2017) instead uses predictions from a model obtained by averaging the weights of a set of models similar to TE, as using the prediction from a unique model is more efficient when a large amount of unlabeled data is available. Virtual Adversarial Training (Miyato et al., 2018) regularizes the network using a measure of local smoothness of the conditional label distribution given the input, defined as the robustness of the prediction to local adversarial perturbations in the input space. Introduced in Zhang et al. (2018), mixup trains a neural network on convex combinations of instance pairs and their respective labels, and has been shown to reduce the memorization of corrupted labels.
+
+# B SENSITIVITY ANALYSIS
+
+In practice, the confidence scores obtained may not be accurate. Therefore, we run a sensitivity analysis to assess the robustness of ILFC: similarly to Ishida et al. (2018), we add a zero-mean Gaussian noise with standard deviation $\sigma \in \{ 0 . 0 , 0 . 3 , 0 . 6 \}$ to each confidence score and clip the values between 0 and 1. Figure 5 shows the resulting performances on the synthetic dataset. ILFC shows good robustness to inaccurate confidence scores even with high standard deviation on a highly noisy dataset.
+
+![](images/644617f6b06a4dc2c09b9b2ec1045135d13f5af60f31f4467df73cf59d672c00.jpg)  
+Figure 5: Sensitivity analysis on the synthetic dataset: a zero-mean Gaussian noise of standard deviation $\sigma \in \{ 0 . 0 , 0 . 3 , 0 . 6 \}$ is added to each confidence score before running ILFC with the noisy confidence scores.
+
+# C ALGORITHM
+
+We present Algorithm 1 here, which can be referred to Section 3.2 in details.
+
+# D BASELINES
+
+Forward correction. Introduced in Patrini et al. (2017), forward correction estimates a fixed transition matrix $T$ before training, and trains a classifier with the corrected loss $l _ { T } : ( y , \hat { y } ) \mapsto l ( y , T \hat { y } )$ .
+
+Mean absolute error loss. Due to its symmetric property, the Mean Absolute Error (MAE) has been theoretically justified to be robust to label noise under assumptions (Ghosh et al., 2017). However, this loss is more difficult to train, especially on complex datasets.
+
+$L _ { q }$ norm. Introduced in Zhang & Sabuncu (2018), $L _ { q }$ norm attempts to bring the best of both worlds between the CCE and the MAE loss: the CCE is easy to train, while the MAE is robust to label noise. The authors therefore define this loss using the negative box-cox transformation:
+
+$$
+L _ { q } \left( h ( \pmb { x } ) , \pmb { e } _ { j } \right) = \frac { \left( 1 - h _ { j } ( \pmb { x } ) ^ { q } \right) } { q } ,
+$$
+
+so that the $L _ { q }$ tends to the CCE when $q  0$ and to the MAE when $q \ : = \ : 1$ . In the following experiments, we set $q = 0 . 7$ , suggested by authors.
+
+Co-teaching (Han et al., 2018). Co-teaching algorithm is a small-loss approach where two classifiers are trained in parallel. At each epoch, each classifier selects the instances with the smallest
+
+# Algorithm 1: Instance-level Forward Correction
+
+Input confidence-annotated samples $S : = \{ ( x _ { i } , \bar { y } _ { i } , r _ { x _ { i } } ) , i = 1 , \ldots , N \}$ , any loss $l$ , classifier $h ( \cdot )$ , anchor   
+points sets $( S _ { i } ^ { * } ) _ { i = 1 } ^ { K }$ ;   
+(1) Train naive classifier $h _ { \mathrm { n o i s y } }$ on samples $\{ ( x _ { i } , \bar { y } _ { i } ) \} _ { i = 1 } ^ { N }$ ;   
+(2) $\forall 1 \leq i , j \leq K , i \neq j$ , compute $\alpha [ i , j ]$ from Eq. 7 with anchor points set $S _ { i } ^ { * }$ ;   
+(3) $\forall 1 \leq i \leq K$ , initialize $\beta _ { i } ( \cdot ) = 1$ ;   
+for epoch $N = 1 , \dots , N _ { \mathrm { m a x } }$ do // Update diagonal constants (4) $\forall 1 \leq i \leq K$ , compute $\mu [ i ]$ from Eq. 6; for $( x , \bar { y } , r _ { x } ) \in S$ do Set $i = \bar { y }$ ; // Compute diagonal terms (5) Set $T [ i , i ] = r _ { x } \beta _ { i } ( x )$ and $\forall k \in [ [ 1 , K ] \backslash \{ i \} , T [ k , k ] = \mu [ k ]$ ; // Compute non-diagonal terms (6) Set $\forall 1 \leq i , j \leq K$ , s.t. $i \neq j$ , $T [ i , j ] = \alpha [ i , j ] ( 1 - T [ i , i ] )$ ; // Train classifier with instance-level corrected loss (7) Train $h ( \cdot )$ on sample $( x , \bar { y } , r _ { x } )$ with loss $l _ { T }$ ; // Update density ratio estimate (8) Update $\begin{array} { r } { \forall 1 \leq i \leq K , \forall x \in S _ { i } , \beta _ { i } ( x ) = \frac { h _ { \mathrm { n o i s y } _ { i } } ( x ) } { h _ { i } ( x ) } ; } \end{array}$ end   
+end
+
+loss, and feed them to the other network as a training set for the next iteration. This recent work has proved to be a leading benchmark in the field of noisy labels.
+
+# E SYNTHETIC DATASET
+
+![](images/fea01fae305075e3378541773e94a468d528795b02f143fd6f6c19d8dced723b.jpg)  
+(9) Output classifier $h ( \cdot )$ .   
+Figure 6 shows three synthetic datasets, which cover clean, IDN and CSIDN models.   
+Figure 6: Synthetic dataset. The clean distribution (a) consists in three classes of concentric circles. In the IDN setting (b), each point $x$ has a probability $\begin{array} { r } { P ( \bar { Y } \ne Y | x ) = \rho \left( \frac { w \cdot x } { \| w \| \| x \| } + 1 \right) / 2 } \end{array}$ $w = ( 0 , 1 )$ of being corrupted, where $\rho$ is a parameter controlling the mean noise rate. Therefore the noise is the strongest towards the direction $( 0 , 1 )$ and the weakest in the direction $( 0 , - 1 )$ . If corrupted, the label is flipped to another class uniformly. The CSIDN setting (c) is similar to the IDN setting, but each point is associated with measure of the confidence in the assigned label. A lower confidence is represented by a lower opacity in the figure.
+
+# F DECISION BOUNDARIES
+
+Figure 7 shows the decision boundaries of our approach versus the ones of a benchmark model, for different levels of noise. With high levels of noise, a model that does not include any instance-level
+
+modelling will degenerate around the most noisy region of the input space. On the other hand, our model successfully accounts for the high noise in this region and is able to keep consistent predictions.
+
+# G EXAMPLES OF REAL-WORLD DATASETS
+
+For example, the method would be similar to constructing a dataset with images scraped from the web, and automatically labelling them from neighbouring text fields using a classifier such as a recurrent neural network. Then, a small subset of curated images could be used at the beginning of the process to calibrate the classifier, in order to make the predictions of the softmax output faithful to the confidence in each label. This way, we could construct a very large dataset for a very low-cost that, while involving some instance-dependent noise, would be equipped with confidence information and therefore could be tackled with our proposed algorithm.
+
+![](images/94df10814c782664b7b07330ee8cb476753a92782fddb9a62a471907eea3b65c.jpg)  
+Figure 7: Decision boundaries of the learned classifier for the ILFC model (left column) and the $L _ { q }$ norm model (right column). In the presence of highly noisy regions, a classifier that does not include any instance-level information will degenerate in those regions, while the ILFC approach stays consistent with the clean distribution.

parse/train/SyevDaVYwr/SyevDaVYwr_content_list.json

@@ -0,0 +1,1795 @@
+[
+    {
+        "type": "text",
+        "text": "CONFIDENCE SCORES MAKE INSTANCE-DEPENDENTLABEL-NOISE LEARNING POSSIBLE",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning with noisy labels has drawn a lot of attention. In this area, most of recent works only consider class-conditional noise, where the label noise is independent of its input features. This noise model may not be faithful to many real-world applications. Instead, few pioneer works have studied instance-dependent noise, but these methods are limited to strong assumptions on noise models. To alleviate this issue, we introduce confidence-scored instance-dependent noise (CSIDN), where each instance-label pair is associated with a confidence score. The confidence scores are sufficient to estimate the noise functions of each instance with minimal assumptions. Moreover, such scores can be easily and cheaply derived during the construction of the dataset through crowdsourcing or automatic annotation. To handle CSIDN, we design a benchmark algorithm termed instance-level forward correction. Empirical results on synthetic and real-world datasets demonstrate the utility of our proposed method. ",
+        "bbox": [
+            233,
+            268,
+            764,
+            449
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            479,
+            336,
+            496
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The recent success of deep neural networks has increased the need for high-quality labeled data. However, such a labelling process can be time-consuming and costly. A compromise is to resort to weakly-supervised annotations, using crowdsourcing platforms or trained classifiers that annotate the data automatically. These weakly-supervised annotations tend to be low-quality and noisy, which negatively affects the accuracy of high-capacity models due to memorization effects (Zhang et al., 2017). Thus, learning with noisy labels has often drawn a lot of attention. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            597
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Early works on noisy labels studied random classification noise (RCN) for binary classification (Angluin & Laird, 1988; Kearns, 1993). In the RCN model, each instance has its label flipped with a fixed noise rate $\\rho \\in [ 0 , \\frac { 1 } { 2 } )$ . A natural extension of RCN is class-conditional noise (CCN) for multiclass classification (Stempfel & Ralaivola, 2009; Natarajan et al., 2013; Scott et al., 2013; Menon et al., 2015; van Rooyen & Williamson, 2015; Patrini et al., 2016) (Appendix A). In the CCN model, each instance from class $i$ has a fixed probability $\\rho _ { i , j }$ of being assigned to class $j$ . Thus, it is possible to encode some similarity information between classes. For example, we can expect that the image of a “dog” is more likely to be erroneously labelled as “cat” than “boat”. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            714
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To handle the CCN model, a common method is the loss correction, which aims to correct the prediction or the loss of the classifier using an estimated noise transition matrix (Patrini et al., 2017; Sukhbaatar et al., 2015; Goldberger & Ben-Reuven, 2017; Ma et al., 2018). Another common approach is the label correction, which aims to improve the label quality during training. For example, Reed et al. (2015) introduced a bootstrapping scheme. Similarly, Tanaka et al. (2018) proposed to update the weights of a classifier iteratively using noisy labels, and use the updated classifier to yield more high-quality pseudo-labels for the training set. Although these methods have theoretical guarantees, they are unable to cope with real-world noise, e.g., instance-dependent noise (IDN). ",
+        "bbox": [
+            174,
+            722,
+            825,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The IDN model considers a more general noise (Manwani & Sastry, 2013; Ghosh et al., 2014; Menon et al., 2016; Cheng et al., 2017; Menon et al., 2018), where the probability that an instance is mislabeled depends on both its class and features. Intuitively, this noise is quite realistic, as poorquality or ambiguous instances are more likely to be mislabeled in real-world datasets. However, it is much more complex to formulate the IDN model, since the probability of a mislabeled instance is a function of not only the label space but also the input space that can be very high dimensional. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/731106a367c41b412c297e81ee6ba01cdec5229351ce79c5055d266639564434.jpg",
+        "table_caption": [
+            "Table 1: Comparisons between baselines and our work for handling the IDN model. Rate identifiability denotes whether the transition matrix is identifiable. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Approaches</td><td rowspan=1 colspan=1>Multi-class</td><td rowspan=1 colspan=1>Rate-identifiability</td><td rowspan=1 colspan=1>Unbounded-noise</td></tr><tr><td rowspan=1 colspan=1>Du&amp;Cai(2015)</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>Menon et al. (2018)</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>Bootkrajang&amp; Chaijaruwanich (2018)</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td></tr><tr><td rowspan=1 colspan=1>Cheng et al. (2017)</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1>Our work</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td></tr></table>",
+        "bbox": [
+            222,
+            141,
+            774,
+            218
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As a result, several pioneer works have considered stronger assumptions on noise functions. However, stronger assumptions tend to restrict the utility of these works (Table 1). For instance, the boundary-consistent noise model considers stronger noise for samples closer to the decision boundary of the Bayesian optimal classifier (Du & Cai, 2015; Menon et al., 2018). However, such a model is restricted to binary and cannot estimate noise functions. Cheng et al. (2017) recently studied a particular case of the IDN model, where noise functions are upper-bounded. Nonetheless, their method is limited to binary classification and has only been tested on small datasets. ",
+        "bbox": [
+            173,
+            250,
+            825,
+            348
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Instead of simplifying assumptions on noise functions, we propose to tackle the IDN model from the source, by considering confidence scores to be available for the label of each instance. We term this new setting confidence-scored instance-dependent noise (CSIDN, Figure 1c). The confidence scores denote how likely an instance is to be correctly labeled. Assuming that (i) confidence scores are available for each instance, (ii) transitions probabilities to other classes are independent of the instance conditionally on the assigned label being erroneous and (iii) a set of anchor points is available, we derive an instance-level forward correction algorithm which can fully estimate the transition probability for each instance, and subsequently train a robust classifier with a loss-correction method similarly to Patrini et al. (2017). ",
+        "bbox": [
+            174,
+            354,
+            825,
+            481
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "It is noted that confidence scores can be easily and cheaply derived during the construction of the dataset. For example, in crowdsourcing platforms, simply counting how many annotators agree on a given instance can give a notion of how confident a label is. Besides, many real-world datasets are automatically annotated using a trained classifier, such as web-scraped datasets (Tong Xiao et al., 2015) and physiological features inferred from medical records (Agarwal et al., 2016). In these cases, the class-probabilities of the labels assigned by the classifier can be seen as confidence scores, provided that the classifier is well calibrated (Guo et al., 2017). ",
+        "bbox": [
+            173,
+            487,
+            825,
+            584
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To sum up, we first formulate instance-dependent noise in Section 2.1, and expose its robustness challenge in Section 2.2. Then, we explain our motivation to use confidence scores, and propose the confidence-scored instance-dependent noise (CSIDN) model in Section 2.3. Lastly, to handle this new noise model, we present the first practical algorithm termed instance-level forward correction in Section 3, and validate the proposed algorithm through extensive experiments in Section 4. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            661
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 TACKLING INSTANCE-DEPENDENT NOISE FROM THE SOURCE",
+        "text_level": 1,
+        "bbox": [
+            174,
+            683,
+            709,
+            699
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present the IDN model along with the limitations of existing approaches, and introduce the CSIDN model as a tractable instance-dependent noise model. ",
+        "bbox": [
+            171,
+            714,
+            825,
+            743
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 NOISE MODELS: FROM CLASS-CONDITIONAL TO INSTANCE-DEPENDENT NOISE",
+        "text_level": 1,
+        "bbox": [
+            169,
+            761,
+            758,
+            776
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We formulate the problem of learning with noisy labels in this section. Let $D$ be the distribution of a pair of random variables $( X , Y ) \\in { \\mathcal { X } } \\times { \\mathcal { Y } }$ , where $\\boldsymbol { \\mathcal { X } } \\in \\mathbb { R } ^ { d }$ , $\\mathcal { Y } = \\{ 1 , 2 , \\dots , K \\}$ and $K$ is the number of classes. In the classification task with noisy labels, we hope to train a classifier while having only access to samples from a noisy distribution $\\bar { D }$ of random variables $( X , { \\bar { Y } } ) \\in { \\mathcal { X } } \\times { \\mathcal { Y } }$ . Given a point $x$ sampled from $X$ , $\\bar { Y }$ is derived from the random variable $Y$ via a noise transition matrix $\\bar { T ( x ) } = ( T _ { i , j } \\bar { ( x ) } ) _ { i , j = 1 } ^ { K } \\in [ 0 , 1 ] ^ { K \\times K }$ : ",
+        "bbox": [
+            173,
+            786,
+            825,
+            877
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6d394597965f9e03b2e3c66bd8ddd5ce390f9b1ef831257304114c289c2669f9.jpg",
+        "text": "$$\n\\forall 1 \\leq j \\leq K , P ( \\bar { Y } = j | X = x ) = \\sum _ { i = 1 } ^ { K } T _ { i , j } ( x ) P ( Y = i | X = x ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            885,
+            715,
+            928
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/7afb187ee3358601c0112a1211bee06efbe15a18b8956ddda771e16703cb59ee.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of different noise models. Each color represents an observed class $\\bar { y }$ : circles indicate ${ \\bar { y } } = y$ , while crosses indicate $\\bar { y } \\ne y$ . The size of each point represents the confidence scores in the label $\\bar { y }$ : the bigger the point is, the more confident it is. In the CCN model, the noise function only depends on the label of each instance. In the IDN and CSIDN models, the noise function depends on the observed instance $x$ . To illustrate the IDN model, we show a special case called boundary-consistent noise, i.e., points that lie close to the decision boundary are more likely to be mislabelled. Note the CSIDN model varies from the IDN model via confidence scores (Section 2.3). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            108,
+            808,
+            256
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Each noise function $T _ { i , j } : \\mathcal { X } \\mapsto [ 0 , 1 ]$ is defined as $T _ { i , j } ( x ) = P ( \\bar { Y } = j | Y = i , X = x )$ . In the class-conditional noise (CNN) model (Figure 1a), the transition matrix does not depend on the instance $x$ and the noise is entirely characterized by the $K ^ { 2 }$ constants $T _ { i , j }$ . However, in the instancedependent noise (IDN) model (Figure 1b), the transition matrix depends on the actual instance. This tremendously complicates the problem, as the noise is now characterized by $K ^ { 2 }$ functions over the latent space $\\mathcal { X }$ , which can be very high dimensional (e.g., $d \\sim 1 0 ^ { 4 } – 1 0 ^ { 6 }$ for an object recognition dataset). ",
+        "bbox": [
+            174,
+            393,
+            825,
+            492
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 CHALLENGES FROM INSTANCE-DEPENDENT NOISE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            513,
+            565,
+            527
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Limitation of existing CCN methods. Due to the complexity of the IDN model, most recent works in learning with noisy labels have focused on the CCN model (Figure 1a), and the CCN model can be seen as a simplified IDN model (Figure 1b) free of feature information. ",
+        "bbox": [
+            176,
+            540,
+            823,
+            583
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In addition to loss correction and label correction mentioned before, another method for the CCN model is sample selection, which aims to find reliable samples during training, such as the smallloss approaches (Jiang et al., 2018; Han et al., 2018). Inspired by the memorization in deep learning (Arpit et al., 2017), those methods first run a standard classifier on a noisy dataset, then select the small-loss samples for reliable training. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            660
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "However, all approaches cannot handle the IDN model directly. Specifically, loss correction considers the noise model to be characterized by a fixed transition matrix, which does not include any instance-level information. Meanwhile, label correction is vulnerable to the IDN model, since the classifier will be much weaker on noisy regions and labels corrected by the current prediction would likely be erroneous. Similarly, sample selection is easily affected by the IDN model. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For example, in the small-loss approaches, instance-dependent noise functions can leave partial regions of the input space clean and other regions very noisy (e.g., in an object recognition dataset, poor-quality pictures will tend to receive more noisy labels than high-quality ones). Since clean regions will tend to receive smaller losses than noisy regions, the small-loss approaches, which only trains on points with the smallest-losses, will focus on clean regions and neglect harder noisy regions. Then, since the distribution of clean regions will subsequently be different from the global distribution, this will introduce a covariate-shift (Shimodaira, 2000), which greatly degrades performances. Moreover, it is hard to use importance reweighting (Sugiyama et al., 2007) for alleviate the issue, since importance reweighting would require estimating the clean posterior probability that is intractable for the IDN model. ",
+        "bbox": [
+            173,
+            742,
+            825,
+            882
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To validate this fact, we generate a 3-class distribution of concentric circles (cf. Figure 2a), with $\\forall ( x , y ) \\in \\mathbb { R } ^ { 2 } \\times \\{ 1 , 2 , 3 \\}$ , $\\begin{array} { r } { P ( \\bar { y } \\neq y | x ) = \\frac { 1 } { 2 } \\left( \\frac { w \\cdot x } { \\| w \\| \\| x \\| } + 1 \\right) } \\end{array}$ with $w = ( 0 , 1 )$ (cf. Figure 2b). We then train a network on the top $R ( T )$ small-loss instances at each epoch $T$ based on the losses of the previous epoch, with $R ( T )$ decreasing in $T$ as described in Han et al. (2018). Figure 2c shows the density of the top $5 0 \\%$ small-loss instances selected after 10 epochs: since noisy regions are associated to higher losses, the network eventually tends to select instances from the clean region and neglect the noisy region. This leads to covariate-shift, which is associated with decreased performances (Shimodaira, 2000). ",
+        "bbox": [
+            174,
+            888,
+            825,
+            928
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/50adae055b1e41d3db4403c2fc38f99c340f916125eb84994d44527331c19db5.jpg",
+        "image_caption": [
+            "Figure 2: The limitation of the small-loss approaches in the IDN model. (a) Clean distribution. (b) instance-dependent noise in the direction $w = ( 0 , 1 )$ with an average corruption rate of $40 \\%$ : points towards the upper region are more likely to be corrupted than points towards the bottom region. (c) Density map of the instances selected by a small-loss approach at epoch 10. The sample selection gets biased towards clean regions. Since the clean and noisy regions have different distributions, selecting most instances from clean regions creates a covariate-shift between the training and test distributions, which can greatly degrades performances. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            106,
+            816,
+            285
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            424,
+            825,
+            508
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Limitation of pioneer IDN methods. The main challenge of the IDN model is the wide range of possible noise functions included in its formulation. Since each $T _ { i , j } ( \\cdot )$ is a function of the highdimensional input space $\\mathcal { X }$ , it is challenging for a model to be flexible enough to fit any real-world noise function while being trainable on corrupted datasets, let alone derive theoretical results. Instead, various recent works have considered stronger assumptions on noise functions. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            597
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For instance, boundary-consistent noise (BCN), first introduced by (Du & Cai, 2015) and generalized in Menon et al. (2018), considers stronger noise for samples closer to the decision boundary of the Bayesian optimal classifier. This is a reasonable model for noise from human annotators, since “harder” instances (i.e., instances closer to the decision boundary) are more likely to be corrupted. Moreover, it is simple enough to derive some theoretical guarantees, as done in Menon et al. (2018). Additionally, an extension of the BCN model was studied in Bootkrajang & Chaijaruwanich (2018), where the noise function is a Gaussian mixture of the distance to the Bayesian optimal boundary. However, the BCN model and its extension are restricted to binary classification, and their geometry-based assumption becomes difficult to fathom for high-dimensional input spaces. ",
+        "bbox": [
+            174,
+            604,
+            825,
+            729
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, Cheng et al. (2017) recently studied a particular case of the IDN model, where the probabilities that the true labels of samples flip into corrupted ones have upper bounds. They proposed a method based on distilled samples, where noisy labels agree with the optimal Bayesian classifier on the clean distribution. However, their method is limited to binary classification and has only been tested on small UCI datasets. Table 1 summarizes the characteristics of those approaches. ",
+        "bbox": [
+            174,
+            736,
+            823,
+            806
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 CONFIDENCE-SCORED INSTANCE-DEPENDENT NOISE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            827,
+            580,
+            840
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Instead of simplifying assumptions on noise functions, we propose to tackle the IDN model from the source. Namely, we consider that, for each instance, we have access to a measure of confidence in the assigned label. As most of noisy datasets arise from crowdsourcing or automatic annotation, such confidence scores can be easily derived during the dataset construction, often with no extra cost. This allows for a good approximation of noise functions with weaker assumptions. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Before introducing our proposed noise model confidence-scored instance-dependent noise (CSIDN, Figure 1c), we first define what are the confidence scores, and explain why the confidence scores are available in real-world applications. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Definition of confidence scores. For any data point $( x , { \\bar { y } } )$ sampled from the joint distribution $( X , { \\bar { Y } } )$ , we define the confidence score $r _ { x }$ as follows. ",
+        "bbox": [
+            174,
+            160,
+            823,
+            189
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0defd92c7d6d4c5641d4385ed2ae25a6febe0520146b2f7944f848dee2d32990.jpg",
+        "text": "$$\nr _ { x } = P ( Y = \\bar { y } | \\bar { Y } = \\bar { y } , X = x ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            193,
+            611,
+            210
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Namely, the probability that the assigned label is correct. ",
+        "bbox": [
+            174,
+            214,
+            547,
+            229
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Availability of confidence scores. Our rationale is that in tasks involving instance-dependent noise, the confidence information can be easily derived with no extra cost. ",
+        "bbox": [
+            173,
+            243,
+            823,
+            272
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Firstly, in crowdsourcing platforms, when multiple workers manually annotate datasets, an aggregation step is often took to aggregate answers of different workers for each instance (e.g., majority vote). An estimation of $r _ { x }$ could then be derived by taking the ratio of votes for the assigned label on the total number of workers. Moreover, since this estimation would of course be less reliable as the number of workers decreases, an alternative could be to directly ask workers for self-reported confidence scores of their responses (Cosmides & Tooby, 1996; Oyama et al., 2013). ",
+        "bbox": [
+            174,
+            279,
+            825,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Secondly, the confidence information can also be available in automatic annotation via a softmax output layer of deep neural networks. This layer outputs an estimation of the probability that each class is the true label: when a model outputs a given class with probability 0.9, we expect the predicted class to be true 9 times out of 10 on average. A model that estimates the accurate probability is well-calibrated. Therefore, in the case of labels generated by a well-calibrated model, the softmax probability of the assigned label can be directly interpreted as a confidence measure that the label is correct. Even though Guo et al. (2017) showed that recent deep neural networks are not usually well-calibrated (whereas early shallower networks were, as shown in Niculescu-Mizil & Caruana (2005)), model calibration can be achieved in a relatively straightforward way at the validation time, e.g., using temperature scaling (Section 4.2 in Guo et al. (2017)). ",
+        "bbox": [
+            174,
+            369,
+            825,
+            508
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "CSIDN: a tractable instance-dependent noise model. Recall the intrinsic difficulty of the IDN model: to fully characterize this noise, one would need to estimate $K ^ { 2 }$ functions $T _ { i , j } ( \\cdot )$ over the input space $\\mathcal { X }$ . This is of course intractable with a finite noisy dataset. This is why pioneer solutions to the IDN model have been so far limited by very strong assumptions. ",
+        "bbox": [
+            174,
+            523,
+            825,
+            579
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "However, considering additional confidence scores, one can wonder whether such information would make the IDN model tractable with less restrictive assumptions. Hence, we introduce a new and tractable instance-dependent noise model: confidence-scored instance-dependent noise (CSIDN, Figure 1c). In this noise model, the training data takes the form ${ \\cal S } : = \\{ ( x _ { i } , \\bar { y } _ { i } , r _ { x _ { i } } ) , i =$ $1 , \\ldots , N \\}$ , where $\\{ ( x _ { i } , { \\bar { y } } _ { i } ) \\} _ { i }$ i.i.d. ∼ $\\bar { D }$ and $r _ { x _ { i } } = P ( Y = \\bar { y } _ { i } | \\bar { Y } = \\bar { y } _ { i } , X = x _ { i } ) $ is the previously defined confidence scores in the assigned label of a given instance (Eq. (2)). The confidence information $r _ { x }$ is decisive for robustness to instance-dependent noise, as it provides a proxy for the noise functions $T _ { i , j }$ of the training data that are often intractable otherwise. ",
+        "bbox": [
+            173,
+            585,
+            825,
+            703
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 BENCHMARK SOLUTION FOR HANDLING THE CSIDN MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            723,
+            710,
+            738
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To tackle the CSIDN model, we propose a benchmark solution. Inspired by forward correction (Patrini et al., 2017) for the CCN model, we want to correct each prediction $P ( { \\bar { y } } | x )$ with the noise transition matrix $T ( x )$ . However, the transition matrix for the CSIDN model is instance-dependent, and has to be estimated for each instance $x$ . We term our solution instance-level forward correction. ",
+        "bbox": [
+            174,
+            753,
+            825,
+            809
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 ESTIMATING INSTANCE-DEPENDENT TRANSITION MATRIX",
+        "text_level": 1,
+        "bbox": [
+            173,
+            827,
+            616,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using the confidence scores, we will first estimate the diagonal terms $( T _ { i , i } ( \\cdot ) ) _ { i = 1 } ^ { K }$ of the transition matrix, and then estimate the non-diagonal ones. ",
+        "bbox": [
+            173,
+            852,
+            825,
+            881
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Diagonal terms. The diagonal terms of the transition matrix correspond to the probabilities that assigned labels are equal to true labels. However, the confidence scores available are only relevant ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "to the class corresponding to the observed label. Therefore, we need to proceed differently whether the confidence scores are available for the considered class or not. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "First, note that for each sample $( x , \\bar { y } , r _ { x } ) \\in S _ { i } : = \\{ ( x , \\bar { y } , r _ { x } ) \\in S | \\bar { y } = i \\} ,$ , $T _ { i , i } ( x )$ can be derived for the most part from the confidence scores alone: ",
+        "bbox": [
+            171,
+            138,
+            825,
+            167
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e0255e24accf2334e2d8baf814d51704517e9e0258349037748ae91b242bb0b3.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\forall ( x , \\bar { y } , r _ { x } ) \\in S _ { i } , \\ T _ { i , i } ( x ) = P ( \\bar { Y } = i | Y = i , X = x ) } \\\\ & { \\qquad = P ( Y = i | \\bar { Y } = i , X = x ) \\frac { P ( \\bar { Y } = i | X = x ) } { P ( Y = i | X = x ) } } \\\\ & { \\qquad = r _ { x } \\ \\beta _ { i } ( x ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            171,
+            735,
+            248
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$\\begin{array} { r } { \\beta _ { i } ( x ) = \\frac { P ( \\bar { Y } = i | X = x ) } { P ( Y = i | X = x ) } } \\end{array}$ ",
+        "bbox": [
+            174,
+            253,
+            362,
+            276
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In practice, we use an iterative procedure to estimate in turn $\\beta _ { i } ( \\cdot )$ and $T _ { i , i } ( \\cdot )$ (see Section 3.2 for details). Then, for the rest of samples $( x , \\bar { y } , r _ { x } ) \\in S \\backslash S _ { i }$ , $r _ { x }$ does not give any direct information on $T _ { i , i } ( \\cdot )$ . Hence, we simply set each function $T _ { i , i } ( \\cdot )$ as its empirical mean $\\mu _ { i }$ estimated using samples from $S _ { i }$ at the current epoch: ",
+        "bbox": [
+            174,
+            282,
+            823,
+            338
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dc33b4e8e5c9c2f08c2b5efd55ba234724c24b83b922f409302b545e23e8d4f3.jpg",
+        "text": "$$\n\\forall ( x , y , r _ { x } ) \\in S \\backslash S _ { i } , \\ \\hat { T } _ { i , i } ( x ) = \\frac { 1 } { | S _ { i } | } \\sum _ { ( x ^ { \\prime } , \\bar { y } ^ { \\prime } , r _ { x } ^ { \\prime } ) \\in S _ { i } } T _ { i , i } ( x ^ { \\prime } ) = \\mu _ { i } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            344,
+            702,
+            386
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $| S |$ denotes the cardinality of $S$ . ",
+        "bbox": [
+            174,
+            392,
+            428,
+            407
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Non-diagonal terms. For non-diagonal terms, we have: ",
+        "bbox": [
+            173,
+            422,
+            553,
+            438
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/23a81a71ce91fd390520d6c24a3ec62f2c9cf8cf53c2e9c04f216645ad2678d4.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\forall i \\neq j , \\forall x \\in \\mathcal { X } , T _ { i , j } ( x ) = P ( \\hat { Y } = j | Y = i , X = x ) } \\\\ & { \\qquad = P ( \\hat { Y } = j , \\hat { Y } \\neq i | Y = i , X = x ) } \\\\ & { \\qquad = P ( \\hat { Y } = j | \\hat { Y } \\neq i , Y = i , X = x ) P ( \\hat { Y } \\neq i | Y = i , X = x ) } \\\\ & { \\qquad = \\alpha _ { i , j } ( x ) ( 1 - T _ { i , i } ( x ) ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            443,
+            781,
+            520
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha _ { i , j } ( x ) = P ( \\bar { Y } = j | \\bar { Y } \\neq i , Y = i , X = x )$ . ",
+        "bbox": [
+            173,
+            525,
+            508,
+            544
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Eq. (4), $\\alpha _ { i , j } ( x )$ refers to the probability that an instance $x$ with true label $i$ has an observed label $j$ , once we know that the observed label is different from the true one. Then, a reasonable assumption is that $\\forall i \\neq j , \\forall x \\in \\mathcal { X } , \\alpha _ { i , j } ( x ) = \\alpha _ { i , j }$ : conditionally on the observed label being erroneous, the class transitions are not influenced by the instance $x$ . In other words, the dependence in $x$ of the noise function only impacts the “magnitude” of the noise and not the class transitions. ",
+        "bbox": [
+            173,
+            547,
+            825,
+            618
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To illustrate this assumption, consider a crowdsourcing task of object recognition with adjacent classes which annotators can only differentiate with details that can be more or less visible depending on the instance. For example, objects from a given class may have distinctive traits, but those can be more or less visible in the pictures. When those traits are present, the annotators can confidently predict the right class. Otherwise, they will make errors towards adjacent classes. In this case, the probability that the assigned label is wrong highly depends the instance (with distinctive traits being visible or not). Nonetheless, conditionally on the instance being corrupted, i.e., because those traits were not visible enough on the image, the transition probabilities to the adjacent classes are not influenced by the instance itself. ",
+        "bbox": [
+            173,
+            625,
+            825,
+            751
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "With the previous assumption, we obtain $\\forall i \\neq j , \\forall x \\in \\mathcal { X } , T _ { i , j } ( x ) = \\alpha _ { i , j } ( 1 - T _ { i , i } ( x ) )$ with $\\alpha _ { i , j } \\in$ $[ 0 , 1 ]$ . This allows us to estimate the $K ( K { - } 1 )$ constants $( \\alpha _ { i , j } ) _ { i \\neq j }$ once, and derive the non-diagonal noise functions of $T ( x )$ directly from our estimates of the diagonal noise functions (Eq. (5)). ",
+        "bbox": [
+            174,
+            756,
+            825,
+            800
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 OVERALL ALGORITHM: INSTANCE-LEVEL FORWARD CORRECTION ",
+        "bbox": [
+            173,
+            816,
+            674,
+            832
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Estimating $T _ { i , i }$ and $\\beta _ { i }$ . To train a classifier $h$ with the instance-level forward correction method, we need to estimate both $T _ { i , i } ( x )$ and $\\begin{array} { r } { \\beta _ { i } ( x ) = \\frac { P ( \\bar { Y } = i | X = x ) } { P ( Y = i | X = x ) } } \\end{array}$ from Eq. (3), for all $x \\in S _ { i }$ . Firstly, the noisy posterior $P ( \\bar { Y } = i \\vert X = x )$ can be easily estimated by training a naive classifier on the noisy dataset. Secondly, the true posterior $P ( Y = i \\vert X = x )$ can be estimated using the output of the classifier $h ( x ) = \\hat { P } ( Y = i \\vert X = x )$ at the previous epoch. ",
+        "bbox": [
+            173,
+            842,
+            826,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Therefore, we iteratively update $\\hat { \\beta }$ and $\\hat { T }$ with the following steps: 1) $\\forall x \\in { \\mathcal { X } }$ , initialize $\\hat { \\beta } _ { i } ( x ) = 1$ and train a naive classifier $h _ { \\mathrm { n o i s y } }$ on the noisy data $\\bar { D }$ to obtain $h _ { \\mathrm { n o i s y } } ( x ) = \\hat { P } ( \\bar { Y } | X = x )$ . 2) $\\forall i \\in [ 1 , K ]$ , for each sample $( x , { \\bar { y } } , r _ { x } ) \\in S _ { i }$ , compute $\\hat { T } _ { i , i } ( x ) = r _ { x } \\hat { \\beta } _ { i } ( x )$ and train classifier $h$ for one epoch. 3) $\\forall i \\in [ 1 , K ]$ , for each sample $( x , \\bar { y } , r _ { x } ) \\in S _ { i }$ , update $\\begin{array} { r } { \\hat { \\beta } _ { i } ( x ) = \\frac { h _ { \\mathrm { n o i s y } } ( x ) _ { i } } { h ( x ) _ { i } } } \\end{array}$ . Then, we repeat steps 2) and 3) through training. In this way, for every epoch, each function $T _ { i , i } ( \\cdot )$ is estimated for the samples from $S _ { i }$ . Lastly, for the rest of samples with noisy label $j \\neq i , T _ { i , i } ( \\cdot )$ is estimated at each epoch using Eq. (4): ",
+        "bbox": [
+            173,
+            101,
+            826,
+            215
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c32be37f356be81fb02e3983becc63f781b5a52f485c7c60ee03762e61d8467b.jpg",
+        "text": "$$\n\\forall ( x , y , r _ { x } ) \\in S \\backslash S _ { i } , \\ \\hat { T } _ { i , i } ( x ) = \\frac { 1 } { | S _ { i } | } \\sum _ { ( x ^ { \\prime } , \\bar { y } ^ { \\prime } , r _ { x } ^ { \\prime } ) \\in S _ { i } } r _ { x } ^ { \\prime } \\hat { \\beta } _ { i } ( x ^ { \\prime } ) = \\mu _ { i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            220,
+            707,
+            261
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Computing $\\alpha _ { i , j }$ . The computation of $\\alpha _ { i , j }$ boils down to approximating non-diagonal terms of the transition matrix in the CCN model. As $\\forall i \\neq j , \\forall x \\in \\mathcal { X }$ , $\\bar { T _ { i , j } } ( x ) = \\alpha _ { i , j } \\bar { ( 1 - T _ { i , i } ( x ) ) }$ , we have: ",
+        "bbox": [
+            173,
+            275,
+            825,
+            304
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b715779e6003eb9be84057938bbfd1d102e950963426f69d325ac5c2c1144dba.jpg",
+        "text": "$$\n\\mathbb { E } _ { x } \\left[ T _ { i , j } ( x ) \\right] = \\alpha _ { i , j } \\left( 1 - \\mathbb { E } _ { x } \\left[ T _ { i , i } ( x ) \\right] \\right) \\Leftrightarrow \\alpha _ { i , j } = \\frac { \\mathbb { E } _ { x } \\left[ T _ { i , j } ( x ) \\right] } { 1 - \\mathbb { E } _ { x } \\left[ T _ { i , i } ( x ) \\right] } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            310,
+            715,
+            344
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A simple and reliable way is to use anchor points, i.e., points for which we can know the true class almost surely. These points may be directly available when some training data has been curated, or they can be identified either theoretically as in Liu & Tao (2015) or heuristically as in Patrini et al. (2017). Having $S _ { i } ^ { * } : = \\{ ( x , \\bar { y } , r _ { x } ) \\in S \\dot { | } P ( Y = i | X = x ) \\approx 1 \\}$ a set of class $i$ anchor points, we simply need compute: ",
+        "bbox": [
+            173,
+            351,
+            826,
+            421
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/634212a21de4780a114f632af29e768c80405e69df6ec673776b51ae6a638adc.jpg",
+        "text": "$$\n\\forall ( x , \\bar { y } , r _ { x } ) \\in S _ { i } ^ { * } , \\forall j \\neq i , T _ { i , i } ( x ) = r _ { x } P ( \\bar { Y } = i | X = x ) \\mathrm { ~ a n d ~ } T _ { i , j } ( x ) = P ( \\bar { Y } = j | X = x ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            426,
+            799,
+            445
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Two noisy posteriors can be estimated using the same classifier $h _ { \\mathrm { n o i s y } }$ trained on the noisy distribution $h _ { \\mathrm { n o i s y } } ( x ) = \\hat { P } ( \\bar { Y } | X = x )$ aforementioned. Thus, $\\alpha _ { i , j }$ can be estimated as follows: ",
+        "bbox": [
+            171,
+            450,
+            823,
+            483
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6204913a145e228dc324b86ea55e10ad0eebc5d61bee215861873658368ab4af.jpg",
+        "text": "$$\n\\forall 1 \\leq i , j \\leq K , j \\neq i , \\alpha _ { i , j } = \\frac { \\frac { 1 } { | S _ { i } ^ { * } | } \\displaystyle \\sum _ { ( x , \\bar { y } , r _ { x } ) \\in S _ { i } ^ { * } } h _ { \\sf n o i s y } ( x ) _ { j } } { 1 - \\frac { 1 } { | S _ { i } ^ { * } | } \\displaystyle \\sum _ { ( x , \\bar { y } , r _ { x } ) \\in S _ { i } ^ { * } } r _ { x } h _ { \\sf n o i s y } ( x ) _ { i } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            489,
+            709,
+            551
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Summary of the training procedure. Given samples $S$ and $K$ sets of anchor points $( S _ { i } ^ { * } ) _ { i = 1 } ^ { K }$ , we want to train a classifier $h ( \\cdot )$ equipped with a loss . For any loss $l : y , \\hat { y } \\mapsto l ( y , \\hat { y } )$ , we define the $T$ -corrected loss as $l _ { T } : y , \\hat { y } \\mapsto l ( y , T \\hat { y } )$ . The overall procedure is in Algorithm 1 (Appendix C). ",
+        "bbox": [
+            176,
+            565,
+            823,
+            609
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            628,
+            326,
+            645
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare our instance-level forward correction (ILFC) method with four representative baselines: forward correction (FC) (Patrini et al., 2017), mean absolute error (MAE) (Ghosh et al., 2017), $L _ { q }$ - norm (LQ) (Zhang & Sabuncu, 2018) and $^ { c o }$ -teaching (CT) (Han et al., 2018). Details are shown in Appendix D. Note that the pioneer IDN methods cannot work for multi-class cases. ",
+        "bbox": [
+            173,
+            660,
+            825,
+            717
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 SYNTHETIC DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            734,
+            362,
+            748
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Generation process. We generate a synthetic dataset (Appendix E) consisting in three classes of concentric circles (Figure 6a). We then apply the following instance-dependent noise to each label: $\\begin{array} { r } { P ( \\bar { Y } \\neq Y | X = x ) = \\rho \\left( \\frac { w \\cdot x } { \\| w \\| \\| x \\| } + 1 \\right) / 2 } \\end{array}$ with $w = ( 0 , 1 )$ and $\\rho$ controlling the mean noise rate. If corrupted, each label is flipped to another class uniformly. ",
+        "bbox": [
+            173,
+            760,
+            825,
+            825
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Empirical results. Figure 3 shows the test accuracy of different methods on the synthetic dataset. Each experiment is repeated 5 times and we plot the confidence intervals of each curve. On low-level noise, all methods show good performances (Figure 3a). On mild-level noise, both Co-teaching and ILFC show good performances and outperform other baselines (Figure 3b). On high-level noise, the performance of all the baselines collapse, whereas ILFC constantly maintains good performances (Figures 3c and 3d). More experiments are shown in Appendix B and F. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/42892105c57033420bd847ee05651166407e1c98941ded80a9f3229d3e4d5fd8.jpg",
+        "image_caption": [
+            "Figure 3: The test accuracy on synthetic datasets with different levels of IDN noise. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            101,
+            830,
+            244
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/feac86cd47140d0d778a7cf60d1baa990b5a96a01beabb548e35fb12a8debd9f.jpg",
+        "image_caption": [
+            "Figure 4: The test accuracy on real-world datasets with different levels of IDN noise. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            284,
+            810,
+            425
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 REAL-WORLD DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            478,
+            379,
+            491
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Generation process. In order to corrupt labels from clean datasets such as SVHN and CIFAR10, we adopt the following procedure: (1) train a classifier $h : x \\mapsto \\sigma ( g ( x ) )$ on a small subset of the clean dataset; (2) using a small validation set, calibrate the classifier by selecting the temperature $t$ that maximizes the expected calibration error as in Guo et al. (2017); (3) for each instance $x$ , set: ${ \\bar { y } } = \\operatorname { a r g m a x } _ { i }$ $h _ { t } ( x ) _ { i }$ and $r _ { x } = \\operatorname* { m a x } _ { i } h _ { t } ( x ) _ { i }$ . With this process, we attempt to emulate the construction of a real-world dataset (Appendix G). ",
+        "bbox": [
+            173,
+            502,
+            825,
+            587
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Empirical results. Figures 4a and 4b show the test accuracy on SVHN with $2 5 \\%$ and $4 5 \\%$ instance-dependent noise, respectively. We can clearly observe that, on both low-level and highlevel noise, ILFC shows good performances with a fast convergence rate, and outperforms other baselines. Figures $_ \\mathrm { 4 c }$ and 4d show the test accuracy on CIFAR10 with $2 5 \\%$ and $4 5 \\%$ instancedependent noise, respectively. On low-level noise, all methods show good performances. However, on high-level noise, ILFC shows a fast convergence rate and outperforms other baselines. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            685
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            705,
+            318,
+            722
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we give an overview of label-noise learning from class-conditional noise (easier) to instance-dependent noise (harder). We explain why existing approaches cannot handle instancedependent noise well, and try to address this challenge via confidence scores. Thus, we formally propose the confidence-scored instance-dependent noise (CSIDN) model. To tackle the CSIDN model, we design a practical algorithm termed instance-level forward correction (ILFC). Our ILFC method robustly outperforms existing methods, especially in the case of high-level noise. In future works, we would like to extend label correction and sample selection approaches with the confidence scores from the CSIDN model. ",
+        "bbox": [
+            174,
+            737,
+            825,
+            849
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Vibhu Agarwal, Tanya Podchiyska, Juan M Banda, Veena Goel, Tiffany I Leung, Evan P Minty, Timothy E Sweeney, Elsie Gyang, and Nigam H Shah. Learning statistical models of phenotypes using noisy labeled training data. Journal of the American Medical Informatics Association, 23 (6):1166–1173, 2016. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            181
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dana Angluin and Philip Laird. Learning from noisy examples. Machine Learning, 2(4):343–370, 1988. ",
+        "bbox": [
+            173,
+            190,
+            823,
+            219
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Devansh Arpit, Stanisław Jastrzebski, Nicolas Ballas, David Krueger, Emmanuel Bengio, Maxinder S Kanwal, Tegan Maharaj, Asja Fischer, Aaron Courville, Yoshua Bengio, et al. A closer look at memorization in deep networks. In ICML, 2017. ",
+        "bbox": [
+            176,
+            228,
+            821,
+            271
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jakramate Bootkrajang and Jeerayut Chaijaruwanich. Towards instance-dependent label noisetolerant classification: a probabilistic approach. Pattern Analysis and Applications, pp. 1–17, 2018. ",
+        "bbox": [
+            176,
+            280,
+            823,
+            321
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Steve Branson, Grant Van Horn, and Pietro Perona. Lean crowdsourcing: Combining humans and machines in an online system. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            332,
+            823,
+            359
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nontawat Charoenphakdee, Jongyeong Lee, and Masashi Sugiyama. On Symmetric Losses for Learning from Corrupted Labels. ICML, 2019. ",
+        "bbox": [
+            176,
+            368,
+            821,
+            398
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jiacheng Cheng, Tongliang Liu, Kotagiri Ramamohanarao, and Dacheng Tao. Learning with bounded instance-and label-dependent label noise. stat, 1050:12, 2017. ",
+        "bbox": [
+            176,
+            406,
+            821,
+            435
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Leda Cosmides and John Tooby. Are humans good intuitive statisticians after all? rethinking some conclusions from the literature on judgment under uncertainty. Cognition, 58(1):1–73, 1996. ",
+        "bbox": [
+            173,
+            444,
+            823,
+            473
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jun Du and Zhihua Cai. Modelling class noise with symmetric and asymmetric distributions. In AAAI, 2015. ",
+        "bbox": [
+            174,
+            481,
+            821,
+            511
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aritra Ghosh, Naresh Manwani, and P S. Sastry. Making risk minimization tolerant to label noise. Neurocomputing, 160, 2014. ",
+        "bbox": [
+            173,
+            518,
+            821,
+            547
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aritra Ghosh, Himanshu Kumar, and PS Sastry. Robust loss functions under label noise for deep neural networks. In AAAI, 2017. ",
+        "bbox": [
+            173,
+            556,
+            821,
+            585
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jacob Goldberger and Ehud Ben-Reuven. Training deep neural-networks using a noise adaptation layer. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            594,
+            823,
+            623
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Melody Y Guan, Varun Gulshan, Andrew M Dai, and Geoffrey E Hinton. Who said what: Modeling individual labelers improves classification. In AAAI, 2018. ",
+        "bbox": [
+            173,
+            631,
+            823,
+            661
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q Weinberger. On calibration of modern neural networks. In ICML, 2017. ",
+        "bbox": [
+            173,
+            669,
+            821,
+            699
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bo Han, Quanming Yao, Xingrui Yu, Gang Niu, Miao Xu, Weihua Hu, Ivor Tsang, and Masashi Sugiyama. Co-teaching: Robust training of deep neural networks with extremely noisy labels. In NeurIPS, 2018. ",
+        "bbox": [
+            173,
+            707,
+            825,
+            750
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Takashi Ishida, Gang Niu, and Masashi Sugiyama. Binary classification from positive-confidence data. In NeurIPS, 2018. ",
+        "bbox": [
+            173,
+            758,
+            821,
+            787
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lu Jiang, Zhengyuan Zhou, Thomas Leung, Li-Jia Li, and Li Fei-Fei. Mentornet: Learning datadriven curriculum for very deep neural networks on corrupted labels. In ICML, 2018. ",
+        "bbox": [
+            171,
+            795,
+            821,
+            825
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael Kearns. Efficient noise-tolerant learning from statistical queries. Proceedings of the twentyfifth annual ACM symposium on Theory of computing - STOC 93, 1993. ",
+        "bbox": [
+            173,
+            833,
+            823,
+            863
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ashish Khetan, Zachary C. Lipton, and Anima Anandkumar. Learning from noisy singly-labeled data. In ICLR, 2018. ",
+        "bbox": [
+            174,
+            871,
+            823,
+            900
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Samuli Laine and Timo Aila. Temporal Ensembling for Semi-Supervised Learning. ICLR, 2017. ",
+        "bbox": [
+            173,
+            909,
+            805,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tongliang Liu and Dacheng Tao. Classification with noisy labels by importance reweighting. IEEE Transactions on pattern analysis and machine intelligence, 38(3):447–461, 2015. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xingjun Ma, Yisen Wang, Michael E. Houle, Shuo Zhou, Sarah Erfani, Shutao Xia, Sudanthi Wijewickrema, and James Bailey. Dimensionality-driven learning with noisy labels. In ICML, 2018. ",
+        "bbox": [
+            171,
+            140,
+            821,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Naresh Manwani and P. S. Sastry. Noise tolerance under risk minimization. IEEE Transactions on Cybernetics, 43:1146–1151, 2013. ",
+        "bbox": [
+            173,
+            178,
+            821,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hamed Masnadi-shirazi and Nuno Vasconcelos. On the Design of Loss Functions for Classification: theory, robustness to outliers, and SavageBoost. In NeurIPS. 2009. ",
+        "bbox": [
+            171,
+            215,
+            823,
+            244
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aditya Menon, Brendan Van Rooyen, Cheng Soon Ong, and Bob Williamson. Learning from corrupted binary labels via class-probability estimation. In ICML, pp. 125–134, 2015. ",
+        "bbox": [
+            173,
+            252,
+            823,
+            284
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aditya Krishna Menon, Brendan Van Rooyen, and Nagarajan Natarajan. Learning from binary labels with instance-dependent corruption. arXiv preprint arXiv:1605.00751, 2016. ",
+        "bbox": [
+            171,
+            291,
+            821,
+            320
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aditya Krishna Menon, Brendan van Rooyen, and Nagarajan Natarajan. Learning from binary labels with instance-dependent noise. Machine Learning, 107(8-10):1561–1595, September 2018. ",
+        "bbox": [
+            173,
+            328,
+            823,
+            358
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence, 41(8):1979–1993, 2018. ",
+        "bbox": [
+            176,
+            366,
+            823,
+            409
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nagarajan Natarajan, Inderjit S Dhillon, Pradeep K Ravikumar, and Ambuj Tewari. Learning with Noisy Labels. In NeurIPS. 2013. ",
+        "bbox": [
+            171,
+            416,
+            823,
+            445
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexandru Niculescu-Mizil and Rich Caruana. Predicting good probabilities with supervised learning. In ICML, 2005. ",
+        "bbox": [
+            173,
+            454,
+            823,
+            483
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Satoshi Oyama, Yukino Baba, Yuko Sakurai, and Hisashi Kashima. Accurate integration of crowdsourced labels using workers’ self-reported confidence scores. In IJCAI, 2013. ",
+        "bbox": [
+            173,
+            492,
+            821,
+            521
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Giorgio Patrini, Frank Nielsen, Richard Nock, and Marcello Carioni. Loss factorization, weakly supervised learning and label noise robustness. In ICML, 2016. ",
+        "bbox": [
+            171,
+            529,
+            821,
+            559
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Giorgio Patrini, Alessandro Rozza, Aditya Krishna Menon, Richard Nock, and Lizhen Qu. Making deep neural networks robust to label noise: A loss correction approach. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            566,
+            823,
+            597
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vikas C Raykar, Shipeng Yu, Linda H Zhao, Anna Jerebko, Charles Florin, Gerardo Hermosillo Valadez, Luca Bogoni, and Linda Moy. Supervised learning from multiple experts: whom to trust when everyone lies a bit. In ICML, 2009. ",
+        "bbox": [
+            176,
+            604,
+            823,
+            647
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Scott Reed, Honglak Lee, Dragomir Anguelov, Christian Szegedy, Dumitru Erhan, and Andrew Rabinovich. Training deep neural networks on noisy labels with bootstrapping. ICLR, 2015. ",
+        "bbox": [
+            174,
+            656,
+            821,
+            685
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Clayton Scott, Gilles Blanchard, and Gregory Handy. Classification with asymmetric label noise: Consistency and maximal denoising. In COLT, pp. 489–511, 2013. ",
+        "bbox": [
+            174,
+            693,
+            821,
+            723
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yanyao Shen and Sujay Sanghavi. Learning with bad training data via iterative trimmed loss minimization. In ICML, 2019. ",
+        "bbox": [
+            173,
+            731,
+            821,
+            760
+        ],
+        "page_idx": 9
+    },
+    {
+        "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,
+            768,
+            821,
+            797
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rion Snow, Brendan O’Connor, Daniel Jurafsky, and Andrew Ng. Cheap and fast – but is it good? evaluating non-expert annotations for natural language tasks. In EMNLP, 2008. ",
+        "bbox": [
+            174,
+            805,
+            820,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Stempfel and Liva Ralaivola. Learning SVMs from sloppily labeled data. In International Conference on Artificial Neural Networks, pp. 884–893, 2009. ",
+        "bbox": [
+            173,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Masashi Sugiyama, Matthias Krauledat, and Klaus-Robert MA˜ zller. Covariate shift adaptation by ˇ importance weighted cross validation. Journal of Machine Learning Research, 8(May):985–1005, 2007. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Joan Bruna, Manohar Paluri, Lubomir Bourdev, and Rob Fergus. Training convolutional networks with noisy labels. ICLR workshop, 2015.   \nDaiki Tanaka, Daiki Ikami, Toshihiko Yamasaki, and Kiyoharu Aizawa. Joint optimization framework for learning with noisy labels. In CVPR, 2018.   \nAntti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In NeurIPS, 2017.   \nTong Xiao, Tian Xia, Yi Yang, Chang Huang, and Xiaogang Wang. Learning from massive noisy labeled data for image classification. In CVPR, 2015.   \nBrendan van Rooyen and Robert C. Williamson. Learning in the Presence of Corruption. arXiv e-prints, art. arXiv:1504.00091, Mar 2015.   \nYan Yan, Romer Rosales, Glenn Fung, Mark Schmidt, Gerardo Hermosillo, Luca Bogoni, Linda ´ Moy, and Jennifer Dy. Modeling annotator expertise: Learning when everybody knows a bit of something. In AISTATS, 2010.   \nChiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In ICLR, 2017.   \nHongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. ICLR, 2018.   \nZhilu Zhang and Mert Sabuncu. Generalized Cross Entropy Loss for Training Deep Neural Networks with Noisy Labels. In NeurIPS. 2018. ",
+        "bbox": [
+            169,
+            102,
+            826,
+            450
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            354,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Besides the works aforementioned, we survey other approaches to learning with noisy labels. ",
+        "bbox": [
+            171,
+            133,
+            781,
+            148
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Robust losses. Various approaches propose to use a provably robust loss function in the learning process. In the case of class-dependent label noise, Natarajan et al. (2013) constructed an unbiased estimator of any loss function under the noisy distribution. Masnadi-shirazi & Vasconcelos (2009) introduced a robust non-convex loss. Recently, works on symmetric losses showed that such loss offer theoretical robustness results to various types of noise (Ghosh et al., 2017; Charoenphakdee et al., 2019). Motivated by the robustness to noise of the mean absolute error loss (MAE) shown in Ghosh et al. (2017), Zhang & Sabuncu (2018) introduced generalized cross entropy loss that allows for a trade-off between the efficient learning properties of the CCE loss and the noise-robustness of MAE. Shen & Sanghavi (2019) introduced a trimmed loss with an iterative minimization process that allows for theoretical guarantees in the simpler setting of generalized linear models. ",
+        "bbox": [
+            174,
+            165,
+            825,
+            304
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Annotator-level modelling. Another recent line of related works attempts to model labels and worker’s quality directly during the crowdsourcing annotation process, in order to produce more accurate labels efficiently. Branson et al. (2017) modeled the annotators’ skill and instances difficulty while incrementally training a computer vision model during the annotation process, effectively reducing the time burden of the annotation process as well as the error rate in the assigned labels. Guan et al. (2018) modeled each annotator individually in order to better aggregate labels based on each worker’s skill and area of expertise. Khetan et al. (2018) introduced a method that allows to learn each workers’ skill even when each example is only annotated once, by jointly modelling the assigned labels and the workers during the annotation process. ",
+        "bbox": [
+            174,
+            321,
+            825,
+            446
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Learning with multiple noisy labels. A closely related setting is learning from multiple noisy labels, where the aim is to predict an unknown ground-truth label from $( X , ( Y ^ { \\bar { j } } ) _ { j } )$ , each $Y ^ { j }$ referring to a noisy annotation. This setting can arise for example from crowdsourcing tasks; Snow et al. (2008) showed that using multiple non-expert annotators to train a classifier can be as effective as using gold standard annotations from experts. In Raykar et al. (2009), the authors derive a Bayesian approach to jointly learn the expertise of each annotator, the actual true label and the classifier. Yan et al. (2010) extends this Bayesian approach by considering that each annotator’s expertise varies across the input space. This setting differs from ours as it takes place before the aggregation of multiple annotations, which, for CSIDN, is only a way among others to obtain a confidence score for each noisy label. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            603
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Explicit/implicit regularizers. Recently, several other regularization techniques have shown good robustness in weakly-supervised settings. Temporal Ensembling (TE) (Laine & Aila, 2017) method labels some additional unlabeled instances using a consensus of predictions from models from previous epochs and with different regularizations and input augmentation conditions. Mean-teacher (MT) (Tarvainen & Valpola, 2017) instead uses predictions from a model obtained by averaging the weights of a set of models similar to TE, as using the prediction from a unique model is more efficient when a large amount of unlabeled data is available. Virtual Adversarial Training (Miyato et al., 2018) regularizes the network using a measure of local smoothness of the conditional label distribution given the input, defined as the robustness of the prediction to local adversarial perturbations in the input space. Introduced in Zhang et al. (2018), mixup trains a neural network on convex combinations of instance pairs and their respective labels, and has been shown to reduce the memorization of corrupted labels. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            785
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B SENSITIVITY ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            808,
+            405,
+            824
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In practice, the confidence scores obtained may not be accurate. Therefore, we run a sensitivity analysis to assess the robustness of ILFC: similarly to Ishida et al. (2018), we add a zero-mean Gaussian noise with standard deviation $\\sigma \\in \\{ 0 . 0 , 0 . 3 , 0 . 6 \\}$ to each confidence score and clip the values between 0 and 1. Figure 5 shows the resulting performances on the synthetic dataset. ILFC shows good robustness to inaccurate confidence scores even with high standard deviation on a highly noisy dataset. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/644617f6b06a4dc2c09b9b2ec1045135d13f5af60f31f4467df73cf59d672c00.jpg",
+        "image_caption": [
+            "Figure 5: Sensitivity analysis on the synthetic dataset: a zero-mean Gaussian noise of standard deviation $\\sigma \\in \\{ 0 . 0 , 0 . 3 , 0 . 6 \\}$ is added to each confidence score before running ILFC with the noisy confidence scores. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            101,
+            792,
+            482
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            570,
+            313,
+            587
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We present Algorithm 1 here, which can be referred to Section 3.2 in details. ",
+        "bbox": [
+            173,
+            602,
+            676,
+            616
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D BASELINES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            636,
+            305,
+            652
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Forward correction. Introduced in Patrini et al. (2017), forward correction estimates a fixed transition matrix $T$ before training, and trains a classifier with the corrected loss $l _ { T } : ( y , \\hat { y } ) \\mapsto l ( y , T \\hat { y } )$ . ",
+        "bbox": [
+            173,
+            666,
+            823,
+            695
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Mean absolute error loss. Due to its symmetric property, the Mean Absolute Error (MAE) has been theoretically justified to be robust to label noise under assumptions (Ghosh et al., 2017). However, this loss is more difficult to train, especially on complex datasets. ",
+        "bbox": [
+            173,
+            709,
+            825,
+            753
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "$L _ { q }$ norm. Introduced in Zhang & Sabuncu (2018), $L _ { q }$ norm attempts to bring the best of both worlds between the CCE and the MAE loss: the CCE is easy to train, while the MAE is robust to label noise. The authors therefore define this loss using the negative box-cox transformation: ",
+        "bbox": [
+            174,
+            767,
+            825,
+            810
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eb088697642b0afa3f6d0435786e7e77515ed37f1883ecbc9816c36bf2eaa224.jpg",
+        "text": "$$\nL _ { q } \\left( h ( \\pmb { x } ) , \\pmb { e } _ { j } \\right) = \\frac { \\left( 1 - h _ { j } ( \\pmb { x } ) ^ { q } \\right) } { q } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            814,
+            602,
+            848
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "so that the $L _ { q }$ tends to the CCE when $q  0$ and to the MAE when $q \\ : = \\ : 1$ . In the following experiments, we set $q = 0 . 7$ , suggested by authors. ",
+        "bbox": [
+            171,
+            852,
+            825,
+            881
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Co-teaching (Han et al., 2018). Co-teaching algorithm is a small-loss approach where two classifiers are trained in parallel. At each epoch, each classifier selects the instances with the smallest ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Instance-level Forward Correction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            107,
+            493,
+            121
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Input confidence-annotated samples $S : = \\{ ( x _ { i } , \\bar { y } _ { i } , r _ { x _ { i } } ) , i = 1 , \\ldots , N \\}$ , any loss $l$ , classifier $h ( \\cdot )$ , anchor   \npoints sets $( S _ { i } ^ { * } ) _ { i = 1 } ^ { K }$ ;   \n(1) Train naive classifier $h _ { \\mathrm { n o i s y } }$ on samples $\\{ ( x _ { i } , \\bar { y } _ { i } ) \\} _ { i = 1 } ^ { N }$ ;   \n(2) $\\forall 1 \\leq i , j \\leq K , i \\neq j$ , compute $\\alpha [ i , j ]$ from Eq. 7 with anchor points set $S _ { i } ^ { * }$ ;   \n(3) $\\forall 1 \\leq i \\leq K$ , initialize $\\beta _ { i } ( \\cdot ) = 1$ ;   \nfor epoch $N = 1 , \\dots , N _ { \\mathrm { m a x } }$ do // Update diagonal constants (4) $\\forall 1 \\leq i \\leq K$ , compute $\\mu [ i ]$ from Eq. 6; for $( x , \\bar { y } , r _ { x } ) \\in S$ do Set $i = \\bar { y }$ ; // Compute diagonal terms (5) Set $T [ i , i ] = r _ { x } \\beta _ { i } ( x )$ and $\\forall k \\in [ [ 1 , K ] \\backslash \\{ i \\} , T [ k , k ] = \\mu [ k ]$ ; // Compute non-diagonal terms (6) Set $\\forall 1 \\leq i , j \\leq K$ , s.t. $i \\neq j$ , $T [ i , j ] = \\alpha [ i , j ] ( 1 - T [ i , i ] )$ ; // Train classifier with instance-level corrected loss (7) Train $h ( \\cdot )$ on sample $( x , \\bar { y } , r _ { x } )$ with loss $l _ { T }$ ; // Update density ratio estimate (8) Update $\\begin{array} { r } { \\forall 1 \\leq i \\leq K , \\forall x \\in S _ { i } , \\beta _ { i } ( x ) = \\frac { h _ { \\mathrm { n o i s y } _ { i } } ( x ) } { h _ { i } ( x ) } ; } \\end{array}$ end   \nend ",
+        "bbox": [
+            171,
+            122,
+            805,
+            390
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "loss, and feed them to the other network as a training set for the next iteration. This recent work has proved to be a leading benchmark in the field of noisy labels. ",
+        "bbox": [
+            173,
+            435,
+            823,
+            463
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E SYNTHETIC DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            483,
+            385,
+            498
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/fea01fae305075e3378541773e94a468d528795b02f143fd6f6c19d8dced723b.jpg",
+        "image_caption": [
+            "(9) Output classifier $h ( \\cdot )$ . ",
+            "Figure 6 shows three synthetic datasets, which cover clean, IDN and CSIDN models. ",
+            "Figure 6: Synthetic dataset. The clean distribution (a) consists in three classes of concentric circles. In the IDN setting (b), each point $x$ has a probability $\\begin{array} { r } { P ( \\bar { Y } \\ne Y | x ) = \\rho \\left( \\frac { w \\cdot x } { \\| w \\| \\| x \\| } + 1 \\right) / 2 } \\end{array}$ $w = ( 0 , 1 )$ of being corrupted, where $\\rho$ is a parameter controlling the mean noise rate. Therefore the noise is the strongest towards the direction $( 0 , 1 )$ and the weakest in the direction $( 0 , - 1 )$ . If corrupted, the label is flipped to another class uniformly. The CSIDN setting (c) is similar to the IDN setting, but each point is associated with measure of the confidence in the assigned label. A lower confidence is represented by a lower opacity in the figure. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            549,
+            800,
+            718
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "F DECISION BOUNDARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            864,
+            405,
+            880
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Figure 7 shows the decision boundaries of our approach versus the ones of a benchmark model, for different levels of noise. With high levels of noise, a model that does not include any instance-level ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "modelling will degenerate around the most noisy region of the input space. On the other hand, our model successfully accounts for the high noise in this region and is able to keep consistent predictions. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "G EXAMPLES OF REAL-WORLD DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            166,
+            539,
+            183
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For example, the method would be similar to constructing a dataset with images scraped from the web, and automatically labelling them from neighbouring text fields using a classifier such as a recurrent neural network. Then, a small subset of curated images could be used at the beginning of the process to calibrate the classifier, in order to make the predictions of the softmax output faithful to the confidence in each label. This way, we could construct a very large dataset for a very low-cost that, while involving some instance-dependent noise, would be equipped with confidence information and therefore could be tackled with our proposed algorithm. ",
+        "bbox": [
+            173,
+            196,
+            825,
+            295
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/94df10814c782664b7b07330ee8cb476753a92782fddb9a62a471907eea3b65c.jpg",
+        "image_caption": [
+            "Figure 7: Decision boundaries of the learned classifier for the ILFC model (left column) and the $L _ { q }$ norm model (right column). In the presence of highly noisy regions, a classifier that does not include any instance-level information will degenerate in those regions, while the ILFC approach stays consistent with the clean distribution. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            230,
+            311,
+            769,
+            849
+        ],
+        "page_idx": 14
+    }
+]

parse/train/qqUMpzcNswxen/qqUMpzcNswxen.md

@@ -0,0 +1,226 @@
+# Deep Convolutional Ranking for Multilabel Image Annotation
+
+Yunchao Gong UNC Chapel Hill yunchao@cs.unc.edu
+
+Yangqing Jia Google Research jiayq@google.com
+
+Thomas K. Leung Google Research leungt@google.com
+
+Alexander Toshev Google Research toshev@google.com
+
+Sergey Ioffe Google Research sioffe@google.com
+
+# Abstract
+
+Multilabel image annotation is one of the most important challenges in computer vision with many real-world applications. While existing work usually use conventional visual features for multilabel annotation, features based on Deep Neural Networks have shown potential to significantly boost performance. In this work, we propose to leverage the advantage of such features and analyze key components that lead to better performances. Specifically, we show that a significant performance gain could be obtained by combining convolutional architectures with approximate top- $k$ ranking objectives, as thye naturally fit the multilabel tagging problem. Our experiments on the NUS-WIDE dataset outperforms the conventional visual features by about $10 \%$ , obtaining the best reported performance in the literature.
+
+# 1 Introduction
+
+Multilabel image annotation [25, 14] is an important and challenging problem in computer vision. Most existing work focus on single-label classification problems [6, 21], where each image is assumed to have only one class label. However, this is not necessarily true for real world applications, as an image may be associated with multiple semantic tags (Figure 1). As a practical example, images from Flickr are usually accompanied by several tags to describe the content of the image, such as objects, activities, and scene descriptions. Images on the Internet, in general, are usually associated with sentences or descriptions, instead of a single class label, which may be deemed as a type of multitagging. Therefore, it is a practical and important problem to accurately assign multiple labels to one image.
+
+Single-label image classification has been extensively studied in the vision community, the most recent advances reported on the large-scale ImageNet database [6]. Most existing work focus on designing visual features for improving recognition accuracy. For example, sparse coding [33, 36], Fisher vectors [28], and VLAD [18] have been proposed to reduce the quantization error of “bag of words”-type features. Spatial pyramid matching [21] has been developed to encode spatial information for recognition. Very recently, deep convolutional neural networks (CNN) have demonstrated promising results for single-label image classification [20]. Such algorithms have all focused on learning a better feature representation for one-vs-rest classification problems, and it is not yet clear how to best train an architecture for multilabel annotation problems.
+
+In this work, we are interested in leveraging the highly expressive convolutional network for the problem of multilabel image annotation. We employed a similar network structure to [20], which contains several convolutional and dense connected layers as the basic architecture. We studied and compared several other popular multilabel losses, such as the ranking loss [19] that optimizes the area under ROC curve (AUC), and the cross-entropy loss used in Tagprop [14]. Specifically, we propose to use the top- $k$ ranking loss, inspired by [34], for embedding to train the network. Using the largest publicly available multilabel dataset NUS-WIDE [4], we observe a significant performance boost over conventional features, reporting the best retrieval performance on the benchmark dataset in the literature.
+
+![](images/31d7040b6a1aa4696054d15b184b5d36b4cc6047694b2b9736316fed2ea032e9.jpg)  
+Figure 1: Sample images from the NUS-WIDE dataset, where each image is annotated with several tags.
+
+# 1.1 Previous Work
+
+In this section we first review related works on multilabel image annotation and then briefly discuss works on deep convolutional networks.
+
+Modeling Internet images and their corresponding textural information (e.g., sentences, tags) have been of great interest in the vision community [2, 10, 12, 15, 30, 29, 34]. In this work, we focus on the image annotation problem and summarize several important lines of related research. Early work in this area was mostly devoted to annotation models inspired by machine translation techniques [1, 8]. The work by Barnard et al. [1, 8] applied machine translation methods to parse natural images and tried to establish a relationship between image regions and words.
+
+More recently, image annotation has been formulated as a classification problem. Early works focused on generative model based tagging [1, 3, 26], centred upon the idea of learning a parametric model to perform predictions. However, because image annotation is a highly nonlinear problem, a parametric model might not be sufficient to capture the complex distribution of the data. Several recent works on image tagging have mostly focused on nonparametric nearest-neighbor methods, which offer higher expressive power. The work by Makadia et al. [25], which proposed a simple nearest-neighbor-based tag transfer approach, achieved significant improvement over previous model-based methods. Recent improvements on the nonparametric approach include TagProp [14], which learns a discriminative metric for nearest neighbors to improve tagging.
+
+Convolutional neural networks (CNNs) [20, 22, 23, 17, 5] are a special type of neural network that utilizes specific network structures, such as convolutions and spatial pooling, and have exhibited good generalization power in image-related applications. Combined with recent techniques such as Dropout and fast parallel training, CNN models have outperformed existing hancrafted features. Krizhevsky et al. [20] reported record-breaking results on ILSVRC 2012 that contains 1000 visualobject categories. However, this study was mostly concerned with single-label image classification, and the images in the dataset only contain one prominent object class. At a finer scale, several methods focus on improving specific network designs. Notably, Zeiler et al. [37] investigated different pooling methods for training CNNs, and several different regularization methods, such as Dropout [16], DropConnect [32], and Maxout [13] have been proposed to improve the robustness and representation power of the networks. In adition, Earlier studies [7] have shown that CNN features are suitable as a general feature for various tasks under the conventional classification schemes, and our work focuses on how to directly train a deep network from raw pixels, using multilabel ranking loss, to address the multilabel annotation problem.
+
+# 2 Multilabel Deep Convolutional Ranking Net
+
+In our approach for multilabel image annotation, we adopted the architecture proposed in [20] as our basic framework and mainly focused on training the network with loss functions tailored for multi-label prediction tasks.
+
+# 2.1 Network Architecture
+
+The basic architecture of the network we use is similar to the one used in [20]. We use five convolutional layers and three densely connected layers. Before feeding the images to the convolutional layers, each image is resized to $2 5 6 \times 2 5 6$ . Next, $2 2 0 \times 2 2 0$ patches are extracted from the whole image, at the center and the four corners to provide an augmentation of the dataset. Convolution filter sizes are set to squares of size 11, 9, and 5 respectively for the different convolutional layers; and max pooling layers are used in some of the convolutional layers to introduce invariance. Each densely connected layer has output sizes of 4096. Dropout layers follow each of the densely connected layers with a dropout ratio of 0.6. For all the layers, we used rectified linear units (RELU) as our nonlinear activation function.
+
+The optimization of the whole network is achieved by asynchronized stochastic gradient descent with a momentum term with weight 0.9, with mini-batch size of 32. The global learning rate for the whole network is set to 0.002 at the beginning, and a staircase weight decay is applied after a few epochs. The same optimization parameters and procedure are applied to all the different methods. For our dataset with 150,000 training images, it usually takes one day to obtain a good model by training on a cluster. Unlike previous work that usually used ImageNet to pre-train the network, we train the whole network directly from the training images from the NUS-WIDE dataset for a fair comparison with conventional vision baselines.
+
+# 2.2 Multilabel Ranking Losses
+
+We mainly focused on loss layer, which specifies how the network training penalizes the deviation between the predicted and true labels, and investigated several different multilabel loss functions for training the network. The first loss function was inspired by Tagprop [14], for which we minimized the multilabel softmax regression loss. The second loss was a simple modification of a pairwiseranking loss [19], which takes multiple labels into account. The third loss function was a multilabel variant of the WARP loss [34], which uses a sampling trick to optimize top- $k$ annotation accuracy.
+
+For notations, assume that we have a set of images $_ { \textbf { \em x } }$ and that we denote the convolutional network by $f ( \cdot )$ where the convolutional layers and dense connected layers filter the images. The output of $f ( \cdot )$ is a scoring function of the data point $_ { \textbf { \em x } }$ , that produces a vector of activations. We assume there are $n$ image training data and $c$ tags.
+
+# 2.2.1 Softmax
+
+The softmax loss has been used for multilabel annotation in Tagprop [14], and is also used in singlelabel image classification [20]; therefore, we adopted it in our context. The posterior probability of an image $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ and class $j$ can be expressed as
+
+$$
+p _ { i j } = \frac { \exp ( f _ { j } ( \pmb { x } _ { i } ) ) } { \sum _ { k = 1 } ^ { c } \exp ( f _ { k } ( \pmb { x } _ { i } ) ) } ,
+$$
+
+where $f _ { j } ( { \pmb x } _ { i } )$ means the activation value for image $\mathbf { \boldsymbol { x } } _ { i }$ and class $j$ . We then minimized the KLDivergence between the predictions and the ground-truth probabilities. Assuming that each image has multiple labels, and that we can form a label vector $\pmb { y } \in R ^ { 1 \times c }$ where $y _ { j } = 1$ means the presence of a label and $y _ { j } = 0$ means absence of a label for an image, we can obtain ground-truth probability by normalizing $\textbf {  { y } }$ as ${ \pmb y } / \| { \pmb y } \| _ { 1 }$ . If the ground truth probability for image $i$ and class $j$ is defined as $\bar { p } _ { i j }$ , the cost function to be minimized is
+
+$$
+J = - { \frac { 1 } { m } } \sum _ { i = 1 } ^ { n } \sum _ { j = 1 } ^ { c } { \bar { p } } _ { i j } \log ( p _ { i j } ) = - { \frac { 1 } { m } } \sum _ { i = 1 } ^ { n } \sum _ { j = 1 } ^ { c _ { + } } { \frac { 1 } { c _ { + } } } \log ( p _ { i j } )
+$$
+
+where $c _ { + }$ denotes the number of positive labels for each image. For the ease of exposition and without loss of generality, we set $c _ { + }$ to be the same for all images.
+
+# 2.2.2 Pairwise Ranking
+
+The second loss function we considered was the pairwise-ranking loss [19], which directly models the annotation problem. In particular, we wanted to rank the positive labels to always have higher
+
+scores than negative labels, which led to the following minimization problem:
+
+$$
+J = \sum _ { i = 1 } ^ { n } \sum _ { j = 1 } ^ { c _ { + } } \sum _ { k = 1 } ^ { c _ { - } } \operatorname* { m a x } ( 0 , 1 - f _ { j } ( { \pmb x } _ { i } ) + f _ { k } ( { \pmb x } _ { i } ) ) ,
+$$
+
+where $c _ { + }$ is the positive labels and $c _ { - }$ is the negative labels. During the back-propagation, we computed the sub-gradient of this loss function. One limitation of this loss is that it optimizes the area under the ROC curve (AUC) but does not directly optimize the top- $k$ annotation accuracy. Because for image annotation problems we were mostly interested in top- $k$ annotations, this pairwise ranking loss did not best fit our purpose.
+
+# 2.2.3 Weighted Approximate Ranking (WARP)
+
+The third loss we considered was the weighted approximate ranking (WARP), which was first described in [34]. It specifically optimizes the top- $k$ accuracy for annotation by using a stochastic sampling approach. Such an approach fits the stochastic optimization framework of the deep architecture very well. It minimizes
+
+$$
+J = \sum _ { i = 1 } ^ { n } \sum _ { j = 1 } ^ { c _ { + } } \sum _ { k = 1 } ^ { c _ { - } } L ( r _ { j } ) \operatorname* { m a x } ( 0 , 1 - f _ { j } ( { \pmb x } _ { i } ) + f _ { k } ( { \pmb x } _ { i } ) ) .
+$$
+
+where $L ( \cdot )$ is a weighting function for different ranks, and $r _ { j }$ is the rank for the $j$ th class for image $i$ . The weighting function $L ( \cdot )$ used in our work is defined as:
+
+$$
+L ( r ) = \sum _ { j = 1 } ^ { r } \alpha _ { j } , \mathrm { w i t h } \alpha _ { 1 } \ge \alpha _ { 2 } \ge . . . \ge 0 .
+$$
+
+We defined the $\alpha _ { i }$ as equal to $1 / j$ , which is the same as [34]. The weights defined by $L ( \cdot )$ control the top- $k$ of the optimization. In particular, if a positive label is ranked top in the label list, then $L ( \cdot )$ will assign a small weight to the loss and will not cost the loss too much. However, if a positive label is not ranked top, $L ( \cdot )$ will assign a much larger weight to the loss, which pushes the positive label to the top. The last question was how to estimate the rank $r _ { j }$ . We followed the sampling method in [34]: for a positive label, we continued to sample negative labels until we found a violation; then we recorded the number of trials s we sampled for negative labels. The rank was estimated by the following formulation
+
+$$
+r _ { j } = \lfloor \frac { c - 1 } { s } \rfloor ,
+$$
+
+for $c$ classes and $s$ sampling trials. We computed the sub-gradient for this layer during optimization.
+
+As a minor noite, the approximate objective we optimize is a looser upper bound compared to the original WARP loss proposed in [34]. To see this, notice that in the original paper, it is assumed that the probability of sampling a violator is $\textstyle p = { \frac { r } { \# Y - 1 } }$ with a positive example $( x , y )$ with rank $r$ , where $\# Y$ is the number of labels. Thus, there are $r$ labels with higher scores than $y$ . This is true only if all these $r$ labels are negative. However, in our case, since there may be other positive labels having higher scores than $y$ due to the multi-label nature of the problem, we effectively have $p \leq \frac { r } { \# Y - 1 }$ .
+
+# 3 Visual Feature based Image Annotation Baslines
+
+We used a set of 9 different visual features and combined them to serve as our baseline features. Although such a set of features might not have been the best possible ones we could obtain, they already serve as a very strong visual representation, and the computation of such features is nontrivial. On top of these features, we ran two simple but powerful classifiers (kNN and SVM) for image annotation. We also experimented with Tagprop [14], but found it cannot easily scale to a large training set because of the $O ( n ^ { 2 } )$ time complexity. After using a small training set to train the Tagprop model, we found the performance to be unsatisfactory and therefore do not compare it here.
+
+# 3.1 Visual Features
+
+GIST [27]: We resized each image to $2 0 0 \times 2 0 0$ and used three different scales [8, 8, 4] to filter each RGB channel, resulting in 960-dimensional $( 3 2 0 \times 3 )$ GIST feature vectors.
+
+SIFT: We used two different sampling methods and three different local descriptors to extract texture features, which gave us a total of 6 different features. We used dense sampling and a Harris corner detector as our patch-sampling methods. For local descriptors, we extracted SIFT [24], CSIFT [31], and RGBSIFT [31], and formed a codebook of size 1000 using kmeans clustering; then built a twolevel spatial pyramid [21] that resulted in a 5000-dimensional vector for each image. We will refer to these six features as D-SIFT, D-CSIFT, D-RGBSIFT, H-SIFT, H-CSIFT, and H-RGBSIFT.
+
+HOG: To represent texture information at a larger scale, we used $2 \times 2$ overlapping HOG as described in [35]. We quantized the HOG features to a codebook of size 1000 and used the same spatial pyramid scheme as above, which resulted in 5000-dimensional feature vectors.
+
+Color: We used a joint RGB color histogram of 8 bins per dimension, for a 512-dimensional feature.
+
+The same set of features were used in [11], and achieved state-of-the-art performance for image retrieval and annotation. The combination of this set of features has a total dimensionality of 36,472, which makes learning very expensive. We followed [11] to perform simple dimensionality reductions to reduce computation. In particular, we performed a kernel PCA (KPCA) separately on each feature to reduce the dimensionality to 500. Then we concatenated all of the feature vectors to form a 4500-dimensional global image feature vector and performed different learning algorithms on it.
+
+# 3.2 Visual feature $\mathbf { \sigma } + k \mathbf { N N }$
+
+The simplest baseline that remains very powerful involves directly applying a weighted kNN on the visual feature vectors. $k \mathbf { N N }$ is a very strong baseline for image annotation, as suggested by Makadia et al. [25], mainly because multilabel image annotation is a highly nonlinear problem and handling the heavily tailed label distribution is usually very difficult. By contrast, kNN is a highly nonlinear and adaptive algorithm that better handles rare tags. For each test image, we found its $k$ nearest neighbors in the training set and computed the posterior probability $p ( c | i )$ as
+
+$$
+p ( c | i ) = \sum _ { j = 1 } ^ { k } \frac { 1 } { k } \exp ( - \frac { | | x _ { i } - x _ { j } | | _ { 2 } ^ { 2 } } { \sigma } ) y _ { j k } ,
+$$
+
+where $y _ { i k }$ indexes the labels of training data, $y _ { i k } = 1$ when there is one label for this image, and $y _ { i k } = 0$ when there is no label for this image. $\sigma$ is the bandwidth that needs to be tuned. After obtaining the prediction probabilities for each image, we sorted the scores and annotated each testing image with the top- $k$ tags.
+
+# 3.3 Visual feature $^ +$ SVM
+
+Another way to perform image annotation is to treat each tag separately and to train $c$ different onevs-all classifiers. We trained a linear SVM [9] for each tag and used the output of the $c$ different SVMs to rank the tags. Because we had already performed nonlinear mapping to the data during the KPCA stage, we found a linear SVM to be sufficient. Thus we assigned top- $k$ tags to one image, based on the ranking of the output scores of the SVMs.
+
+# 4 Experiments
+
+# 4.1 Dataset
+
+We performed experiments on the largest publicly available multilabel dataset, NUS-WIDE [4]. This dataset contains 269,648 images downloaded from Flickr that have been manually annotated, with several tags (2-5 on average) per image. After ignoring the small subset of the images that are not annotated by any tag, we had a total of 209,347 images for training and testing. We used a subset of 150,000 images for training and used the rest of the images for testing. The tag dictionary for the images contains 81 different tags. Some sample images and annotations are shown in Figure 1.
+
+<table><tr><td>method/metric</td><td>per-class recall</td><td>per-class precision</td><td>overall recall</td><td>overall precision</td><td>N+</td></tr><tr><td>Upper bound</td><td>97.00</td><td>44.87</td><td>82.76</td><td>66.49</td><td>100.00</td></tr><tr><td>VisualFeature+kNN</td><td>19.33</td><td>32.59</td><td>53.44</td><td>42.93</td><td>91.36</td></tr><tr><td>Visual Feature+SVM</td><td>18.79</td><td>21.51</td><td>35.87</td><td>28.82</td><td>82.72</td></tr><tr><td>CNN +Softmax</td><td>31.22</td><td>31.68</td><td>59.52</td><td>47.82</td><td>98.76</td></tr><tr><td>CNN +Ranking</td><td>26.83</td><td>31.93</td><td>58.00</td><td>46.59</td><td>95.06</td></tr><tr><td>CNN+WARP</td><td>35.60</td><td>31.65</td><td>60.49</td><td>48.59</td><td>96.29</td></tr></table>
+
+Table 1: Image annotation results on NUS-WIDE with $k = 3$ annotated tags per image. See text in section 5.4 for the definition of “Upper bound”.
+
+<table><tr><td>method/metric</td><td>per-classrecall</td><td>per-class precision</td><td>overall recall</td><td>overall precision</td><td>N+</td></tr><tr><td>Upper bound</td><td>99.57</td><td>28.83</td><td>96.40</td><td>46.22</td><td>100.00</td></tr><tr><td>Visual Feature+kNN</td><td>32.14</td><td>22.56</td><td>66.98</td><td>32.29</td><td>95.06</td></tr><tr><td>Visual Feature+SVM</td><td>34.19</td><td>18.79</td><td>47.15</td><td>22.73</td><td>96.30</td></tr><tr><td>CNN+Softmax</td><td>48.24</td><td>21.98</td><td>74.04</td><td>35.69</td><td>98.76</td></tr><tr><td>CNN+Ranking</td><td>42.48</td><td>22.74</td><td>72.78</td><td>35.08</td><td>97.53</td></tr><tr><td>CNN+WARP</td><td>52.03</td><td>22.31</td><td>75.00</td><td>36.16</td><td>100.00</td></tr></table>
+
+Table 2: Image annotation results on NUS-WIDE with $k = 5$ annotated tags per image. See text in section 5.4 for the definition of “Upper bound”.
+
+# 4.2 Evaluation Protocols
+
+We followed previous research [25] in our use of the following protocols to evaluate different methods. For each image, we assigned $k$ (e.g., $k = 3 , 5$ ) highest-ranked tags to the image and compared the assigned tags to the ground-truth tags. We computed the recall and precision for each tag separately, and then report the mean-per-class recall and mean-per-class precision:
+
+$$
+\mathrm { p e r - c l a s s ~ r e c a l l } = \frac { 1 } { c } \sum _ { i = 1 } ^ { c } \frac { N _ { i } ^ { c } } { N _ { i } ^ { g } } , \quad \mathrm { p e r - c l a s s ~ p r e c i s i o n } = \frac { 1 } { c } \sum _ { i = 1 } ^ { c } \frac { N _ { i } ^ { c } } { N _ { i } ^ { p } }
+$$
+
+where $c$ is the number of tags, $N _ { i } ^ { c }$ is the number of correctly annotated image for tag $i$ , $N _ { i } ^ { g }$ is the number of ground-truth tags for tag $i$ , and $N _ { i } ^ { p }$ is the number of predictions for tag $i$ . The above evaluations are biased toward infrequent tags, because making them correct would have a very significant impact on the final accuracy. Therefore we also report the overall recall and overall precision:
+
+$$
+{ \mathrm { o v e r a l l ~ r e c a l l } } = { \frac { \sum _ { i = 1 } ^ { c } N _ { i } ^ { c } } { \sum _ { i = 1 } ^ { c } N _ { i } ^ { g } } } , \quad { \mathrm { ~ o v e r a l l ~ p r e c i s i o n } } = { \frac { \sum _ { i = 1 } ^ { c } N _ { i } ^ { c } } { \sum _ { i = 1 } ^ { c } N _ { i } ^ { p } } } .
+$$
+
+For the above two metrics, the frequent classes will be dominant and have a larger impact on final performance. Finally, we also report the percentage of recalled tag words out of all tag words as $\Nu +$ . We believe that evaluating all of these metrics makes the evaluation unbiased.
+
+# 4.3 Baseline Parameters
+
+In our preliminary evaluation, we optimized the parameters for the visual-feature-based baseline systems. For visual-feature dimensionality reduction, we followed the suggestions in Gong et al. [11] to reduce the dimensionality of each feature to 500 and then concatenated the PCA-reduced vectors into a 4500-dimensional global image descriptor, which worked as well as the original feature. For $k \mathbf { N N }$ , we set the bandwidth $\sigma$ to 1 and $k$ to 50, having found that these settings work best. For SVM, we set the regularization parameter to $C = 2$ , which works best for this dataset.
+
+# 4.4 Results
+
+We first report results with respect to the metrics introduced above. In particular, we vary the number $k$ of predicted keywords for each image and mainly consider $k = 3$ and $k = 5$ . Before doing so, however, we must define an upper bound for our evaluation. In the dataset, each image had different numbers of ground-truth tags, which made it hard for us to precisely compute an upper bound for performance with different $k$ . For each image, when the number of ground-truth tags was larger than $k$ , we randomly chose $k$ ground-truth tags and assigned them to that image; when the number of ground-truth tags was smaller than $k$ , we assigned all ground-truth tags to that image and randomly chose other tags for that image. We believe this baseline represents the best possible performance when the ground truth is known. The results for assigning 3 keywords per image are reported in Table 1. The results indicate that the deep network achieves a substantial improvement over existing visual-feature-based annotation methods. The $\mathrm { C N N + S }$ oftmax method outperforms the VisualFeature $\mathbf { \partial } _ { + \mathrm { S V M } }$ baseline by about $10 \%$ . Comparing the same CNN network with different loss functions, results show that softmax already gives a very powerful baseline. Although using the pairwise ranking loss does not improve softmax, by using the weighted approximated-ranking loss (WARP) we were able to achieve a substantial improvement over softmax. This is probably because pairwise-ranking is not directly optimizing the top- $k$ accuracy, and because WARP pushes classes that are not ranked top heavier, which boosts the performance of rare tags. From these results, we can see that all loss functions achieved comparable overall-recall and overall-precision, but that WARP loss achieved significantly better per-class recall and per-class precision. Results for $k = 5$ , which are given in Table 2, show similar trends to $k = 3$ .
+
+![](images/b03d8466052269c57ca13abd1c1891842e83550d37954bb7027879f85693e4aa.jpg)  
+Figure 2: Analysis of per-class recall of the 81 tags in NUS-WIDE dataset with $k = 3$
+
+![](images/cfa75304808b04a1abdc7f7f17c46c869a4d539f5f400a1162ec872a1c492736.jpg)  
+Figure 3: Analysis of per-class precision of the 81 tags in NUS-WIDE dataset with $k = 3$
+
+We also provide a more detailed analysis of per-class recall and per-class precision. The recall for each tags appears in Figure 2, and the precision for each tag in Figure 3. The results for different tags are sorted by the frequency of each tag, in descending order. From these results, we see that the accuracy for frequent tags greater than for infrequent tags. Different losses performed comparably to each other for frequent classes, and WARP worked better than other loss functions for infrequent classes. Finally, we show some image annotation examples in Figure 4. Even though some of the predicted tags for these do not match the ground truth, they are still very meaningful.
+
+# 5 Discussion and Future Work
+
+In this work, we proposed to use ranking to train deep convolutional neural networks for multilabel image annotation problems. We investigated several different ranking-based loss functions for training the CNN, and found that the weighted approximated-ranking loss works particularly well for multilabel annotation problems. We performed experiments on the largest publicly available multilabel image dataset NUS-WIDE, and demonstrated the effectiveness of using top- $k$ ranking to train the network. In the future, we would like to use very large amount of noisy-labeled multilabel images from the Internet (e.g., from Flickr or image searches) to train the network.
+
+![](images/5a3325f54a65fc2b449f5f5fa5dcc29e321316972cc339899b112f391cefe362.jpg)  
+Figure 4: Qualitative image annotation results obtained with WARP.
+
+# References
+
+[1] Kobus Barnard and David Forsyth. Learning the semantics of words and pictures. In ICCV, 2001. [2] Tamara Berg and David Forsyth. Animals on the web. CVPR, 2007.   
+[3] Gustavo Carneiro, Antoni B Chan, Pedro J Moreno, and Nuno Vasconcelos. Supervised learning of semantic classes for image annotation and retrieval. Pattern Analysis and Machine Intelligence, IEEE Transactions on, 29(3):394–410, 2007.   
+[4] Tat-Seng Chua, Jinhui Tang, Richang Hong, Haojie Li, Zhiping Luo, and Yan-Tao. Zheng. Nus-wide: A real-world web image database from national university of singapore. In Proc. of ACM Conf. on Image and Video Retrieval (CIVR’09), Santorini, Greece., July 8-10, 2009.   
+[5] Jeffrey Dean, Greg Corrado, Rajat Monga, Kai Chen, Matthieu Devin, Quoc Le, Mark Mao, Marc’Aurelio Ranzato, Andrew Senior, Paul Tucker, Ke Yang, and Andrew Ng. Large scale distributed deep networks. In P. Bartlett, F.C.N. Pereira, C.J.C. Burges, L. Bottou, and K.Q. Weinberger, editors, Advances in Neural Information Processing Systems 25, pages 1232– 1240, 2012.   
+[6] Jia Deng, W. Dong, R. Socher, Lijia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. CVPR, 2009.   
+[7] Jeff Donahue, Yangqing Jia, Oriol Vinyals, Judy Hoffman, Ning Zhang, Eric Tzeng, and Trevor Darrell. Decaf: A deep convolutional activation feature for generic visual recognition. arXiv preprint arXiv:1310.1531, 2013.   
+[8] Pinar Duygulu, Kobus Barnard, Nando de Freitas, and David Forsyth. Object recognition as machine translation: Learning a lexicon for a fixed image vocabulary. In ECCV, 2002.   
+[9] R.-E. Fan, K.-W. Chang, C.-J. Hsieh, X.-R. Wang, and C.-J. Lin. Liblinear: A library for large linear classification. JMLR, 2008.   
+[10] Rob Fergus, Antonio Torralba, and Yair Weiss. Semi-supervised learning in gigantic image collections. NIPS, 2009.   
+[11] Yunchao Gong, Qifa Ke, Michael Isard, and Svetlana Lazebnik. A multi-view embedding space for internet images, tags, and their semantics. IJCV, 2013.   
+[12] Yunchao Gong and Svetlana Lazebnik. Iterative quantization: An procrustean approach to learning binary codes. CVPR, 2011.   
+[13] Ian Goodfellow, David Warde-Farley, Mehdi Mirza, Aaron Courville, and Yoshua Bengio. Maxout networks. ICML, 2013.   
+[14] M. Guillaumin, T. Mensink, J. Verbeek, and C. Schmid. Tagprop: Discriminative metric learning in nearest neighbor models for image auto-annotation. ICCV, 2009.   
+[15] Matthieu Guillaumin, Jakob Verbeek, and Cordelia Schmid. Multimodal semi-supervised learning for image classification. CVPR, 2010.   
+[16] Geoffrey Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. Arxiv, 2012.   
+[17] What is the best multi-stage architecture for object recognition? K. jarrett and k. kavukcuoglu and m. a. ranzato and y. lecun. CVPR, 2009.   
+[18] Herv´Jegou, M. Douze, Cordelia Schmid, and Patrick Perez. Aggregating local descriptors into ´ a compact image representation. CVPR, 2010.   
+[19] Thorsten Joachims. Optimizing search engines using clickthrough data. In Proceedings of the Eighth ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’02, pages 133–142, New York, NY, USA, 2002. ACM.   
+[20] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. NIPS, 2012.   
+[21] Svetlana Lazebnik, Cordelia Schmid, and Jean Ponce. Beyond bags of features: Spatial pyramid matching for recognizing natural scene categories. CVPR, 2006.   
+[22] Y. LeCun, B. Boser, J.S. Denker, D. Henderson, R.E. Howard, W. Hubbard, and L.D. Jackel. Handwritten digit recognition with a back-propagation network. NIPS, 1990.   
+[23] H. Lee, R. Grosse, R. Ranganath, and A.Y. Ng. Convolutional deep belief networks for scalable unsupervised learning of hierarchical representations. ICML, 2009.   
+[24] David G. Lowe. Distinctive image features from scale-invariant keypoints. IJCV, 2004.   
+[25] Ameesh Makadia, Vladimir Pavlovic, and Sanjiv Kumar. A new baseline for image annotation. In ECCV, 2008.   
+[26] F. Monay and D. Gatica-Perez. Plsa-based image autoannotation: Constraining the latent space. In ACM Multimedia, 2004.   
+[27] Aude Oliva and Antonio Torralba. Modeling the shape of the scene: a holistic representation of the spatial envelope. IJCV, 2001.   
+[28] Florent Perronnin and Christopher R. Dance. Fisher kernels on visual vocabularies for image categorization. CVPR, 2007.   
+[29] A. Quattoni, M. Collins, and T. Darrell. Learning visual representations using images with captions. CVPR, 2007.   
+[30] N. Rasiwasia, PJ Moreno, and N. Vasconcelos. Bridging the gap: Query by semantic example. IEEE Transactions on Multimedia, 2007.   
+[31] Koen E. A. van de Sande, Theo Gevers, and Cees G. M. Snoek. Evaluating color descriptors for object and scene recognition. PAMI, 2010.   
+[32] Li Wan, Matt Zeiler, Sixin Zhang, Yann Lecun, and Rob Fergus. Regularization of neural networks using dropconnect. ICML, 2013.   
+[33] Jinjun Wang, Jianchao Yang, Kai Yu, Fengjun Lv, Thomas Huang, and Yihong Gong. Localityconstrained linear coding for image classification. CVPR, 2010.   
+[34] Jason Weston, Samy Bengio, and Nicolas Usunier. Wsabie: Scaling up to large vocabulary image annotation. In IJCAI, 2011.   
+[35] Jianxiong Xiao, James Hays, Krista Ehinger, Aude Oliva, and Antonio Torralba. Sun database: Large-scale scene recognition from abbey to zoo. CVPR, 2010.   
+[36] Jianchao Yang, Kai Yu, Yihong Gong, and Thomas Huang. Linear spatial pyramid matching uisng sparse coding for image classification. CVPR, 2009.   
+[37] Matt Zeiler and Rob Fergus. Stochastic pooling for regularization of deep convolutional neural networks. ICLR, 2013.

parse/train/qqUMpzcNswxen/qqUMpzcNswxen_content_list.json

@@ -0,0 +1,1031 @@
+[
+    {
+        "type": "text",
+        "text": "Deep Convolutional Ranking for Multilabel Image Annotation ",
+        "text_level": 1,
+        "bbox": [
+            302,
+            135,
+            694,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yunchao Gong UNC Chapel Hill yunchao@cs.unc.edu ",
+        "bbox": [
+            218,
+            238,
+            379,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yangqing Jia Google Research jiayq@google.com ",
+        "bbox": [
+            433,
+            238,
+            575,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Thomas K. Leung Google Research leungt@google.com ",
+        "bbox": [
+            627,
+            238,
+            779,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Alexander Toshev Google Research toshev@google.com ",
+        "bbox": [
+            285,
+            301,
+            441,
+            344
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe Google Research sioffe@google.com ",
+        "bbox": [
+            558,
+            301,
+            712,
+            344
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            380,
+            535,
+            396
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Multilabel image annotation is one of the most important challenges in computer vision with many real-world applications. While existing work usually use conventional visual features for multilabel annotation, features based on Deep Neural Networks have shown potential to significantly boost performance. In this work, we propose to leverage the advantage of such features and analyze key components that lead to better performances. Specifically, we show that a significant performance gain could be obtained by combining convolutional architectures with approximate top- $k$ ranking objectives, as thye naturally fit the multilabel tagging problem. Our experiments on the NUS-WIDE dataset outperforms the conventional visual features by about $10 \\%$ , obtaining the best reported performance in the literature. ",
+        "bbox": [
+            233,
+            410,
+            764,
+            563
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            585,
+            310,
+            603
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Multilabel image annotation [25, 14] is an important and challenging problem in computer vision. Most existing work focus on single-label classification problems [6, 21], where each image is assumed to have only one class label. However, this is not necessarily true for real world applications, as an image may be associated with multiple semantic tags (Figure 1). As a practical example, images from Flickr are usually accompanied by several tags to describe the content of the image, such as objects, activities, and scene descriptions. Images on the Internet, in general, are usually associated with sentences or descriptions, instead of a single class label, which may be deemed as a type of multitagging. Therefore, it is a practical and important problem to accurately assign multiple labels to one image. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Single-label image classification has been extensively studied in the vision community, the most recent advances reported on the large-scale ImageNet database [6]. Most existing work focus on designing visual features for improving recognition accuracy. For example, sparse coding [33, 36], Fisher vectors [28], and VLAD [18] have been proposed to reduce the quantization error of “bag of words”-type features. Spatial pyramid matching [21] has been developed to encode spatial information for recognition. Very recently, deep convolutional neural networks (CNN) have demonstrated promising results for single-label image classification [20]. Such algorithms have all focused on learning a better feature representation for one-vs-rest classification problems, and it is not yet clear how to best train an architecture for multilabel annotation problems. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we are interested in leveraging the highly expressive convolutional network for the problem of multilabel image annotation. We employed a similar network structure to [20], which contains several convolutional and dense connected layers as the basic architecture. We studied and compared several other popular multilabel losses, such as the ranking loss [19] that optimizes the area under ROC curve (AUC), and the cross-entropy loss used in Tagprop [14]. Specifically, we propose to use the top- $k$ ranking loss, inspired by [34], for embedding to train the network. Using the largest publicly available multilabel dataset NUS-WIDE [4], we observe a significant performance boost over conventional features, reporting the best retrieval performance on the benchmark dataset in the literature. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/31d7040b6a1aa4696054d15b184b5d36b4cc6047694b2b9736316fed2ea032e9.jpg",
+        "image_caption": [
+            "Figure 1: Sample images from the NUS-WIDE dataset, where each image is annotated with several tags. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            94,
+            823,
+            165
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            239,
+            825,
+            324
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 Previous Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            344,
+            316,
+            359
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section we first review related works on multilabel image annotation and then briefly discuss works on deep convolutional networks. ",
+        "bbox": [
+            176,
+            371,
+            823,
+            400
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Modeling Internet images and their corresponding textural information (e.g., sentences, tags) have been of great interest in the vision community [2, 10, 12, 15, 30, 29, 34]. In this work, we focus on the image annotation problem and summarize several important lines of related research. Early work in this area was mostly devoted to annotation models inspired by machine translation techniques [1, 8]. The work by Barnard et al. [1, 8] applied machine translation methods to parse natural images and tried to establish a relationship between image regions and words. ",
+        "bbox": [
+            174,
+            407,
+            823,
+            491
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "More recently, image annotation has been formulated as a classification problem. Early works focused on generative model based tagging [1, 3, 26], centred upon the idea of learning a parametric model to perform predictions. However, because image annotation is a highly nonlinear problem, a parametric model might not be sufficient to capture the complex distribution of the data. Several recent works on image tagging have mostly focused on nonparametric nearest-neighbor methods, which offer higher expressive power. The work by Makadia et al. [25], which proposed a simple nearest-neighbor-based tag transfer approach, achieved significant improvement over previous model-based methods. Recent improvements on the nonparametric approach include TagProp [14], which learns a discriminative metric for nearest neighbors to improve tagging. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            623
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Convolutional neural networks (CNNs) [20, 22, 23, 17, 5] are a special type of neural network that utilizes specific network structures, such as convolutions and spatial pooling, and have exhibited good generalization power in image-related applications. Combined with recent techniques such as Dropout and fast parallel training, CNN models have outperformed existing hancrafted features. Krizhevsky et al. [20] reported record-breaking results on ILSVRC 2012 that contains 1000 visualobject categories. However, this study was mostly concerned with single-label image classification, and the images in the dataset only contain one prominent object class. At a finer scale, several methods focus on improving specific network designs. Notably, Zeiler et al. [37] investigated different pooling methods for training CNNs, and several different regularization methods, such as Dropout [16], DropConnect [32], and Maxout [13] have been proposed to improve the robustness and representation power of the networks. In adition, Earlier studies [7] have shown that CNN features are suitable as a general feature for various tasks under the conventional classification schemes, and our work focuses on how to directly train a deep network from raw pixels, using multilabel ranking loss, to address the multilabel annotation problem. ",
+        "bbox": [
+            174,
+            630,
+            825,
+            824
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Multilabel Deep Convolutional Ranking Net ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            847,
+            573,
+            864
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In our approach for multilabel image annotation, we adopted the architecture proposed in [20] as our basic framework and mainly focused on training the network with loss functions tailored for multi-label prediction tasks. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Network Architecture ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            364,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The basic architecture of the network we use is similar to the one used in [20]. We use five convolutional layers and three densely connected layers. Before feeding the images to the convolutional layers, each image is resized to $2 5 6 \\times 2 5 6$ . Next, $2 2 0 \\times 2 2 0$ patches are extracted from the whole image, at the center and the four corners to provide an augmentation of the dataset. Convolution filter sizes are set to squares of size 11, 9, and 5 respectively for the different convolutional layers; and max pooling layers are used in some of the convolutional layers to introduce invariance. Each densely connected layer has output sizes of 4096. Dropout layers follow each of the densely connected layers with a dropout ratio of 0.6. For all the layers, we used rectified linear units (RELU) as our nonlinear activation function. ",
+        "bbox": [
+            173,
+            128,
+            825,
+            255
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The optimization of the whole network is achieved by asynchronized stochastic gradient descent with a momentum term with weight 0.9, with mini-batch size of 32. The global learning rate for the whole network is set to 0.002 at the beginning, and a staircase weight decay is applied after a few epochs. The same optimization parameters and procedure are applied to all the different methods. For our dataset with 150,000 training images, it usually takes one day to obtain a good model by training on a cluster. Unlike previous work that usually used ImageNet to pre-train the network, we train the whole network directly from the training images from the NUS-WIDE dataset for a fair comparison with conventional vision baselines. ",
+        "bbox": [
+            173,
+            261,
+            825,
+            373
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Multilabel Ranking Losses ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            390,
+            398,
+            405
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We mainly focused on loss layer, which specifies how the network training penalizes the deviation between the predicted and true labels, and investigated several different multilabel loss functions for training the network. The first loss function was inspired by Tagprop [14], for which we minimized the multilabel softmax regression loss. The second loss was a simple modification of a pairwiseranking loss [19], which takes multiple labels into account. The third loss function was a multilabel variant of the WARP loss [34], which uses a sampling trick to optimize top- $k$ annotation accuracy. ",
+        "bbox": [
+            173,
+            415,
+            825,
+            500
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For notations, assume that we have a set of images $_ { \\textbf { \\em x } }$ and that we denote the convolutional network by $f ( \\cdot )$ where the convolutional layers and dense connected layers filter the images. The output of $f ( \\cdot )$ is a scoring function of the data point $_ { \\textbf { \\em x } }$ , that produces a vector of activations. We assume there are $n$ image training data and $c$ tags. ",
+        "bbox": [
+            174,
+            506,
+            825,
+            563
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2.1 Softmax ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            577,
+            284,
+            592
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The softmax loss has been used for multilabel annotation in Tagprop [14], and is also used in singlelabel image classification [20]; therefore, we adopted it in our context. The posterior probability of an image $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { i } }$ and class $j$ can be expressed as ",
+        "bbox": [
+            173,
+            602,
+            825,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/550ebfc90f269b9b3ef9169e1105e03ba0ab213fb712393ebf9b5867f227d9ce.jpg",
+        "text": "$$\np _ { i j } = \\frac { \\exp ( f _ { j } ( \\pmb { x } _ { i } ) ) } { \\sum _ { k = 1 } ^ { c } \\exp ( f _ { k } ( \\pmb { x } _ { i } ) ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            648,
+            588,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $f _ { j } ( { \\pmb x } _ { i } )$ means the activation value for image $\\mathbf { \\boldsymbol { x } } _ { i }$ and class $j$ . We then minimized the KLDivergence between the predictions and the ground-truth probabilities. Assuming that each image has multiple labels, and that we can form a label vector $\\pmb { y } \\in R ^ { 1 \\times c }$ where $y _ { j } = 1$ means the presence of a label and $y _ { j } = 0$ means absence of a label for an image, we can obtain ground-truth probability by normalizing $\\textbf {  { y } }$ as ${ \\pmb y } / \\| { \\pmb y } \\| _ { 1 }$ . If the ground truth probability for image $i$ and class $j$ is defined as $\\bar { p } _ { i j }$ , the cost function to be minimized is ",
+        "bbox": [
+            173,
+            689,
+            825,
+            773
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/05fddff8a0513970d19af4133c9b322eb7881776d99295beea31c64291fbde01.jpg",
+        "text": "$$\nJ = - { \\frac { 1 } { m } } \\sum _ { i = 1 } ^ { n } \\sum _ { j = 1 } ^ { c } { \\bar { p } } _ { i j } \\log ( p _ { i j } ) = - { \\frac { 1 } { m } } \\sum _ { i = 1 } ^ { n } \\sum _ { j = 1 } ^ { c _ { + } } { \\frac { 1 } { c _ { + } } } \\log ( p _ { i j } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            780,
+            691,
+            824
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $c _ { + }$ denotes the number of positive labels for each image. For the ease of exposition and without loss of generality, we set $c _ { + }$ to be the same for all images. ",
+        "bbox": [
+            171,
+            828,
+            823,
+            857
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2.2 Pairwise Ranking ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            871,
+            349,
+            886
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The second loss function we considered was the pairwise-ranking loss [19], which directly models the annotation problem. In particular, we wanted to rank the positive labels to always have higher ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "scores than negative labels, which led to the following minimization problem: ",
+        "bbox": [
+            173,
+            103,
+            683,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/07bfc2756b0e18dba0d90246a73431455f44175b5d1f581206981a6adaea206a.jpg",
+        "text": "$$\nJ = \\sum _ { i = 1 } ^ { n } \\sum _ { j = 1 } ^ { c _ { + } } \\sum _ { k = 1 } ^ { c _ { - } } \\operatorname* { m a x } ( 0 , 1 - f _ { j } ( { \\pmb x } _ { i } ) + f _ { k } ( { \\pmb x } _ { i } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            127,
+            655,
+            171
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $c _ { + }$ is the positive labels and $c _ { - }$ is the negative labels. During the back-propagation, we computed the sub-gradient of this loss function. One limitation of this loss is that it optimizes the area under the ROC curve (AUC) but does not directly optimize the top- $k$ annotation accuracy. Because for image annotation problems we were mostly interested in top- $k$ annotations, this pairwise ranking loss did not best fit our purpose. ",
+        "bbox": [
+            174,
+            179,
+            825,
+            250
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2.3 Weighted Approximate Ranking (WARP) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            267,
+            514,
+            282
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The third loss we considered was the weighted approximate ranking (WARP), which was first described in [34]. It specifically optimizes the top- $k$ accuracy for annotation by using a stochastic sampling approach. Such an approach fits the stochastic optimization framework of the deep architecture very well. It minimizes ",
+        "bbox": [
+            174,
+            292,
+            825,
+            348
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7536465739fc167c1e40f54aa63f25ff3b5fdff128a38cbfe6f3cd9ce52502d6.jpg",
+        "text": "$$\nJ = \\sum _ { i = 1 } ^ { n } \\sum _ { j = 1 } ^ { c _ { + } } \\sum _ { k = 1 } ^ { c _ { - } } L ( r _ { j } ) \\operatorname* { m a x } ( 0 , 1 - f _ { j } ( { \\pmb x } _ { i } ) + f _ { k } ( { \\pmb x } _ { i } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            357,
+            676,
+            402
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $L ( \\cdot )$ is a weighting function for different ranks, and $r _ { j }$ is the rank for the $j$ th class for image $i$ . The weighting function $L ( \\cdot )$ used in our work is defined as: ",
+        "bbox": [
+            171,
+            410,
+            823,
+            440
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3e33d91bcb0e75bd7f1e4457a633437f32e0ae0924973f3d16bcffa7bb56ab81.jpg",
+        "text": "$$\nL ( r ) = \\sum _ { j = 1 } ^ { r } \\alpha _ { j } , \\mathrm { w i t h } \\alpha _ { 1 } \\ge \\alpha _ { 2 } \\ge . . . \\ge 0 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            448,
+            638,
+            492
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We defined the $\\alpha _ { i }$ as equal to $1 / j$ , which is the same as [34]. The weights defined by $L ( \\cdot )$ control the top- $k$ of the optimization. In particular, if a positive label is ranked top in the label list, then $L ( \\cdot )$ will assign a small weight to the loss and will not cost the loss too much. However, if a positive label is not ranked top, $L ( \\cdot )$ will assign a much larger weight to the loss, which pushes the positive label to the top. The last question was how to estimate the rank $r _ { j }$ . We followed the sampling method in [34]: for a positive label, we continued to sample negative labels until we found a violation; then we recorded the number of trials s we sampled for negative labels. The rank was estimated by the following formulation ",
+        "bbox": [
+            173,
+            500,
+            825,
+            612
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/83b1946399152912e4b13937444e931988693ef00354280c95ca867449061e0f.jpg",
+        "text": "$$\nr _ { j } = \\lfloor \\frac { c - 1 } { s } \\rfloor ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            449,
+            613,
+            547,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "for $c$ classes and $s$ sampling trials. We computed the sub-gradient for this layer during optimization. ",
+        "bbox": [
+            171,
+            648,
+            821,
+            664
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As a minor noite, the approximate objective we optimize is a looser upper bound compared to the original WARP loss proposed in [34]. To see this, notice that in the original paper, it is assumed that the probability of sampling a violator is $\\textstyle p = { \\frac { r } { \\# Y - 1 } }$ with a positive example $( x , y )$ with rank $r$ , where $\\# Y$ is the number of labels. Thus, there are $r$ labels with higher scores than $y$ . This is true only if all these $r$ labels are negative. However, in our case, since there may be other positive labels having higher scores than $y$ due to the multi-label nature of the problem, we effectively have $p \\leq \\frac { r } { \\# Y - 1 }$ . ",
+        "bbox": [
+            173,
+            670,
+            825,
+            773
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Visual Feature based Image Annotation Baslines ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            792,
+            609,
+            810
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We used a set of 9 different visual features and combined them to serve as our baseline features. Although such a set of features might not have been the best possible ones we could obtain, they already serve as a very strong visual representation, and the computation of such features is nontrivial. On top of these features, we ran two simple but powerful classifiers (kNN and SVM) for image annotation. We also experimented with Tagprop [14], but found it cannot easily scale to a large training set because of the $O ( n ^ { 2 } )$ time complexity. After using a small training set to train the Tagprop model, we found the performance to be unsatisfactory and therefore do not compare it here. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Visual Features ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            320,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "GIST [27]: We resized each image to $2 0 0 \\times 2 0 0$ and used three different scales [8, 8, 4] to filter each RGB channel, resulting in 960-dimensional $( 3 2 0 \\times 3 )$ GIST feature vectors. ",
+        "bbox": [
+            173,
+            128,
+            823,
+            157
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "SIFT: We used two different sampling methods and three different local descriptors to extract texture features, which gave us a total of 6 different features. We used dense sampling and a Harris corner detector as our patch-sampling methods. For local descriptors, we extracted SIFT [24], CSIFT [31], and RGBSIFT [31], and formed a codebook of size 1000 using kmeans clustering; then built a twolevel spatial pyramid [21] that resulted in a 5000-dimensional vector for each image. We will refer to these six features as D-SIFT, D-CSIFT, D-RGBSIFT, H-SIFT, H-CSIFT, and H-RGBSIFT. ",
+        "bbox": [
+            173,
+            167,
+            825,
+            251
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "HOG: To represent texture information at a larger scale, we used $2 \\times 2$ overlapping HOG as described in [35]. We quantized the HOG features to a codebook of size 1000 and used the same spatial pyramid scheme as above, which resulted in 5000-dimensional feature vectors. ",
+        "bbox": [
+            174,
+            261,
+            825,
+            303
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Color: We used a joint RGB color histogram of 8 bins per dimension, for a 512-dimensional feature. ",
+        "bbox": [
+            171,
+            313,
+            820,
+            328
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The same set of features were used in [11], and achieved state-of-the-art performance for image retrieval and annotation. The combination of this set of features has a total dimensionality of 36,472, which makes learning very expensive. We followed [11] to perform simple dimensionality reductions to reduce computation. In particular, we performed a kernel PCA (KPCA) separately on each feature to reduce the dimensionality to 500. Then we concatenated all of the feature vectors to form a 4500-dimensional global image feature vector and performed different learning algorithms on it. ",
+        "bbox": [
+            174,
+            337,
+            825,
+            421
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Visual feature $\\mathbf { \\sigma } + k \\mathbf { N N }$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            436,
+            361,
+            452
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The simplest baseline that remains very powerful involves directly applying a weighted kNN on the visual feature vectors. $k \\mathbf { N N }$ is a very strong baseline for image annotation, as suggested by Makadia et al. [25], mainly because multilabel image annotation is a highly nonlinear problem and handling the heavily tailed label distribution is usually very difficult. By contrast, kNN is a highly nonlinear and adaptive algorithm that better handles rare tags. For each test image, we found its $k$ nearest neighbors in the training set and computed the posterior probability $p ( c | i )$ as ",
+        "bbox": [
+            173,
+            463,
+            825,
+            546
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fef62ac37c7cb5ab81c875557c1870b6f90f2716306d32ff2504d43e4b947d5d.jpg",
+        "text": "$$\np ( c | i ) = \\sum _ { j = 1 } ^ { k } \\frac { 1 } { k } \\exp ( - \\frac { | | x _ { i } - x _ { j } | | _ { 2 } ^ { 2 } } { \\sigma } ) y _ { j k } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            549,
+            629,
+            594
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $y _ { i k }$ indexes the labels of training data, $y _ { i k } = 1$ when there is one label for this image, and $y _ { i k } = 0$ when there is no label for this image. $\\sigma$ is the bandwidth that needs to be tuned. After obtaining the prediction probabilities for each image, we sorted the scores and annotated each testing image with the top- $k$ tags. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            652
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Visual feature $^ +$ SVM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            667,
+            364,
+            683
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Another way to perform image annotation is to treat each tag separately and to train $c$ different onevs-all classifiers. We trained a linear SVM [9] for each tag and used the output of the $c$ different SVMs to rank the tags. Because we had already performed nonlinear mapping to the data during the KPCA stage, we found a linear SVM to be sufficient. Thus we assigned top- $k$ tags to one image, based on the ranking of the output scores of the SVMs. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            782,
+            312,
+            800
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Dataset ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            814,
+            266,
+            829
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We performed experiments on the largest publicly available multilabel dataset, NUS-WIDE [4]. This dataset contains 269,648 images downloaded from Flickr that have been manually annotated, with several tags (2-5 on average) per image. After ignoring the small subset of the images that are not annotated by any tag, we had a total of 209,347 images for training and testing. We used a subset of 150,000 images for training and used the rest of the images for testing. The tag dictionary for the images contains 81 different tags. Some sample images and annotations are shown in Figure 1. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/ed74c92cb6161edef7e19b011bfde8ef5cb4486965d5c231842d10cdf5479af8.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>method/metric</td><td>per-class recall</td><td>per-class precision</td><td>overall recall</td><td>overall precision</td><td>N+</td></tr><tr><td>Upper bound</td><td>97.00</td><td>44.87</td><td>82.76</td><td>66.49</td><td>100.00</td></tr><tr><td>VisualFeature+kNN</td><td>19.33</td><td>32.59</td><td>53.44</td><td>42.93</td><td>91.36</td></tr><tr><td>Visual Feature+SVM</td><td>18.79</td><td>21.51</td><td>35.87</td><td>28.82</td><td>82.72</td></tr><tr><td>CNN +Softmax</td><td>31.22</td><td>31.68</td><td>59.52</td><td>47.82</td><td>98.76</td></tr><tr><td>CNN +Ranking</td><td>26.83</td><td>31.93</td><td>58.00</td><td>46.59</td><td>95.06</td></tr><tr><td>CNN+WARP</td><td>35.60</td><td>31.65</td><td>60.49</td><td>48.59</td><td>96.29</td></tr></table>",
+        "bbox": [
+            183,
+            101,
+            815,
+            194
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Image annotation results on NUS-WIDE with $k = 3$ annotated tags per image. See text in section 5.4 for the definition of “Upper bound”. ",
+        "bbox": [
+            173,
+            204,
+            823,
+            233
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/89680829e32d6e3696ecf2cc8cba683a05315905216999f918172b1b2b5f40ea.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>method/metric</td><td>per-classrecall</td><td>per-class precision</td><td>overall recall</td><td>overall precision</td><td>N+</td></tr><tr><td>Upper bound</td><td>99.57</td><td>28.83</td><td>96.40</td><td>46.22</td><td>100.00</td></tr><tr><td>Visual Feature+kNN</td><td>32.14</td><td>22.56</td><td>66.98</td><td>32.29</td><td>95.06</td></tr><tr><td>Visual Feature+SVM</td><td>34.19</td><td>18.79</td><td>47.15</td><td>22.73</td><td>96.30</td></tr><tr><td>CNN+Softmax</td><td>48.24</td><td>21.98</td><td>74.04</td><td>35.69</td><td>98.76</td></tr><tr><td>CNN+Ranking</td><td>42.48</td><td>22.74</td><td>72.78</td><td>35.08</td><td>97.53</td></tr><tr><td>CNN+WARP</td><td>52.03</td><td>22.31</td><td>75.00</td><td>36.16</td><td>100.00</td></tr></table>",
+        "bbox": [
+            183,
+            251,
+            815,
+            344
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Image annotation results on NUS-WIDE with $k = 5$ annotated tags per image. See text in section 5.4 for the definition of “Upper bound”. ",
+        "bbox": [
+            173,
+            354,
+            823,
+            383
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Evaluation Protocols ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            415,
+            357,
+            429
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We followed previous research [25] in our use of the following protocols to evaluate different methods. For each image, we assigned $k$ (e.g., $k = 3 , 5$ ) highest-ranked tags to the image and compared the assigned tags to the ground-truth tags. We computed the recall and precision for each tag separately, and then report the mean-per-class recall and mean-per-class precision: ",
+        "bbox": [
+            173,
+            440,
+            825,
+            497
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/19702c3b8e0793d2370a3092023a6a593ab7d153a6d8d6cef35571a67d405ff1.jpg",
+        "text": "$$\n\\mathrm { p e r - c l a s s ~ r e c a l l } = \\frac { 1 } { c } \\sum _ { i = 1 } ^ { c } \\frac { N _ { i } ^ { c } } { N _ { i } ^ { g } } , \\quad \\mathrm { p e r - c l a s s ~ p r e c i s i o n } = \\frac { 1 } { c } \\sum _ { i = 1 } ^ { c } \\frac { N _ { i } ^ { c } } { N _ { i } ^ { p } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            503,
+            715,
+            545
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $c$ is the number of tags, $N _ { i } ^ { c }$ is the number of correctly annotated image for tag $i$ , $N _ { i } ^ { g }$ is the number of ground-truth tags for tag $i$ , and $N _ { i } ^ { p }$ is the number of predictions for tag $i$ . The above evaluations are biased toward infrequent tags, because making them correct would have a very significant impact on the final accuracy. Therefore we also report the overall recall and overall precision: ",
+        "bbox": [
+            174,
+            550,
+            825,
+            619
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/983e6e185059378fdde2ec5cf730b013e190ebbd15fcb66a77604eda76396430.jpg",
+        "text": "$$\n{ \\mathrm { o v e r a l l ~ r e c a l l } } = { \\frac { \\sum _ { i = 1 } ^ { c } N _ { i } ^ { c } } { \\sum _ { i = 1 } ^ { c } N _ { i } ^ { g } } } , \\quad { \\mathrm { ~ o v e r a l l ~ p r e c i s i o n } } = { \\frac { \\sum _ { i = 1 } ^ { c } N _ { i } ^ { c } } { \\sum _ { i = 1 } ^ { c } N _ { i } ^ { p } } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            618,
+            704,
+            655
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the above two metrics, the frequent classes will be dominant and have a larger impact on final performance. Finally, we also report the percentage of recalled tag words out of all tag words as $\\Nu +$ . We believe that evaluating all of these metrics makes the evaluation unbiased. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            699
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Baseline Parameters ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            715,
+            354,
+            729
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In our preliminary evaluation, we optimized the parameters for the visual-feature-based baseline systems. For visual-feature dimensionality reduction, we followed the suggestions in Gong et al. [11] to reduce the dimensionality of each feature to 500 and then concatenated the PCA-reduced vectors into a 4500-dimensional global image descriptor, which worked as well as the original feature. For $k \\mathbf { N N }$ , we set the bandwidth $\\sigma$ to 1 and $k$ to 50, having found that these settings work best. For SVM, we set the regularization parameter to $C = 2$ , which works best for this dataset. ",
+        "bbox": [
+            173,
+            741,
+            825,
+            825
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.4 Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            842,
+            264,
+            856
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We first report results with respect to the metrics introduced above. In particular, we vary the number $k$ of predicted keywords for each image and mainly consider $k = 3$ and $k = 5$ . Before doing so, however, we must define an upper bound for our evaluation. In the dataset, each image had different numbers of ground-truth tags, which made it hard for us to precisely compute an upper bound for performance with different $k$ . For each image, when the number of ground-truth tags was larger than $k$ , we randomly chose $k$ ground-truth tags and assigned them to that image; when the number of ground-truth tags was smaller than $k$ , we assigned all ground-truth tags to that image and randomly chose other tags for that image. We believe this baseline represents the best possible performance when the ground truth is known. The results for assigning 3 keywords per image are reported in Table 1. The results indicate that the deep network achieves a substantial improvement over existing visual-feature-based annotation methods. The $\\mathrm { C N N + S }$ oftmax method outperforms the VisualFeature $\\mathbf { \\partial } _ { + \\mathrm { S V M } }$ baseline by about $10 \\%$ . Comparing the same CNN network with different loss functions, results show that softmax already gives a very powerful baseline. Although using the pairwise ranking loss does not improve softmax, by using the weighted approximated-ranking loss (WARP) we were able to achieve a substantial improvement over softmax. This is probably because pairwise-ranking is not directly optimizing the top- $k$ accuracy, and because WARP pushes classes that are not ranked top heavier, which boosts the performance of rare tags. From these results, we can see that all loss functions achieved comparable overall-recall and overall-precision, but that WARP loss achieved significantly better per-class recall and per-class precision. Results for $k = 5$ , which are given in Table 2, show similar trends to $k = 3$ . ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/b03d8466052269c57ca13abd1c1891842e83550d37954bb7027879f85693e4aa.jpg",
+        "image_caption": [
+            "Figure 2: Analysis of per-class recall of the 81 tags in NUS-WIDE dataset with $k = 3$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            74,
+            745,
+            210
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/cfa75304808b04a1abdc7f7f17c46c869a4d539f5f400a1162ec872a1c492736.jpg",
+        "image_caption": [
+            "Figure 3: Analysis of per-class precision of the 81 tags in NUS-WIDE dataset with $k = 3$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            239,
+            743,
+            377
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            429,
+            825,
+            650
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also provide a more detailed analysis of per-class recall and per-class precision. The recall for each tags appears in Figure 2, and the precision for each tag in Figure 3. The results for different tags are sorted by the frequency of each tag, in descending order. From these results, we see that the accuracy for frequent tags greater than for infrequent tags. Different losses performed comparably to each other for frequent classes, and WARP worked better than other loss functions for infrequent classes. Finally, we show some image annotation examples in Figure 4. Even though some of the predicted tags for these do not match the ground truth, they are still very meaningful. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            756
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Discussion and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            787,
+            442,
+            804
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this work, we proposed to use ranking to train deep convolutional neural networks for multilabel image annotation problems. We investigated several different ranking-based loss functions for training the CNN, and found that the weighted approximated-ranking loss works particularly well for multilabel annotation problems. We performed experiments on the largest publicly available multilabel image dataset NUS-WIDE, and demonstrated the effectiveness of using top- $k$ ranking to train the network. In the future, we would like to use very large amount of noisy-labeled multilabel images from the Internet (e.g., from Flickr or image searches) to train the network. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5a3325f54a65fc2b449f5f5fa5dcc29e321316972cc339899b112f391cefe362.jpg",
+        "image_caption": [
+            "Figure 4: Qualitative image annotation results obtained with WARP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            84,
+            777,
+            400
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            441,
+            267,
+            458
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "[1] Kobus Barnard and David Forsyth. Learning the semantics of words and pictures. In ICCV, 2001. [2] Tamara Berg and David Forsyth. Animals on the web. CVPR, 2007.   \n[3] Gustavo Carneiro, Antoni B Chan, Pedro J Moreno, and Nuno Vasconcelos. Supervised learning of semantic classes for image annotation and retrieval. Pattern Analysis and Machine Intelligence, IEEE Transactions on, 29(3):394–410, 2007.   \n[4] Tat-Seng Chua, Jinhui Tang, Richang Hong, Haojie Li, Zhiping Luo, and Yan-Tao. Zheng. Nus-wide: A real-world web image database from national university of singapore. In Proc. of ACM Conf. on Image and Video Retrieval (CIVR’09), Santorini, Greece., July 8-10, 2009.   \n[5] Jeffrey Dean, Greg Corrado, Rajat Monga, Kai Chen, Matthieu Devin, Quoc Le, Mark Mao, Marc’Aurelio Ranzato, Andrew Senior, Paul Tucker, Ke Yang, and Andrew Ng. Large scale distributed deep networks. In P. Bartlett, F.C.N. Pereira, C.J.C. Burges, L. Bottou, and K.Q. Weinberger, editors, Advances in Neural Information Processing Systems 25, pages 1232– 1240, 2012.   \n[6] Jia Deng, W. Dong, R. Socher, Lijia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. CVPR, 2009.   \n[7] Jeff Donahue, Yangqing Jia, Oriol Vinyals, Judy Hoffman, Ning Zhang, Eric Tzeng, and Trevor Darrell. Decaf: A deep convolutional activation feature for generic visual recognition. arXiv preprint arXiv:1310.1531, 2013.   \n[8] Pinar Duygulu, Kobus Barnard, Nando de Freitas, and David Forsyth. Object recognition as machine translation: Learning a lexicon for a fixed image vocabulary. In ECCV, 2002.   \n[9] R.-E. Fan, K.-W. Chang, C.-J. Hsieh, X.-R. Wang, and C.-J. Lin. Liblinear: A library for large linear classification. JMLR, 2008.   \n[10] Rob Fergus, Antonio Torralba, and Yair Weiss. Semi-supervised learning in gigantic image collections. NIPS, 2009.   \n[11] Yunchao Gong, Qifa Ke, Michael Isard, and Svetlana Lazebnik. A multi-view embedding space for internet images, tags, and their semantics. IJCV, 2013.   \n[12] Yunchao Gong and Svetlana Lazebnik. Iterative quantization: An procrustean approach to learning binary codes. CVPR, 2011.   \n[13] Ian Goodfellow, David Warde-Farley, Mehdi Mirza, Aaron Courville, and Yoshua Bengio. Maxout networks. ICML, 2013.   \n[14] M. Guillaumin, T. Mensink, J. Verbeek, and C. Schmid. Tagprop: Discriminative metric learning in nearest neighbor models for image auto-annotation. ICCV, 2009.   \n[15] Matthieu Guillaumin, Jakob Verbeek, and Cordelia Schmid. Multimodal semi-supervised learning for image classification. CVPR, 2010.   \n[16] Geoffrey Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. Arxiv, 2012.   \n[17] What is the best multi-stage architecture for object recognition? K. jarrett and k. kavukcuoglu and m. a. ranzato and y. lecun. CVPR, 2009.   \n[18] Herv´Jegou, M. Douze, Cordelia Schmid, and Patrick Perez. Aggregating local descriptors into ´ a compact image representation. CVPR, 2010.   \n[19] Thorsten Joachims. Optimizing search engines using clickthrough data. In Proceedings of the Eighth ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’02, pages 133–142, New York, NY, USA, 2002. ACM.   \n[20] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. NIPS, 2012.   \n[21] Svetlana Lazebnik, Cordelia Schmid, and Jean Ponce. Beyond bags of features: Spatial pyramid matching for recognizing natural scene categories. CVPR, 2006.   \n[22] Y. LeCun, B. Boser, J.S. Denker, D. Henderson, R.E. Howard, W. Hubbard, and L.D. Jackel. Handwritten digit recognition with a back-propagation network. NIPS, 1990.   \n[23] H. Lee, R. Grosse, R. Ranganath, and A.Y. Ng. Convolutional deep belief networks for scalable unsupervised learning of hierarchical representations. ICML, 2009.   \n[24] David G. Lowe. Distinctive image features from scale-invariant keypoints. IJCV, 2004.   \n[25] Ameesh Makadia, Vladimir Pavlovic, and Sanjiv Kumar. A new baseline for image annotation. In ECCV, 2008.   \n[26] F. Monay and D. Gatica-Perez. Plsa-based image autoannotation: Constraining the latent space. In ACM Multimedia, 2004.   \n[27] Aude Oliva and Antonio Torralba. Modeling the shape of the scene: a holistic representation of the spatial envelope. IJCV, 2001.   \n[28] Florent Perronnin and Christopher R. Dance. Fisher kernels on visual vocabularies for image categorization. CVPR, 2007.   \n[29] A. Quattoni, M. Collins, and T. Darrell. Learning visual representations using images with captions. CVPR, 2007.   \n[30] N. Rasiwasia, PJ Moreno, and N. Vasconcelos. Bridging the gap: Query by semantic example. IEEE Transactions on Multimedia, 2007.   \n[31] Koen E. A. van de Sande, Theo Gevers, and Cees G. M. Snoek. Evaluating color descriptors for object and scene recognition. PAMI, 2010.   \n[32] Li Wan, Matt Zeiler, Sixin Zhang, Yann Lecun, and Rob Fergus. Regularization of neural networks using dropconnect. ICML, 2013.   \n[33] Jinjun Wang, Jianchao Yang, Kai Yu, Fengjun Lv, Thomas Huang, and Yihong Gong. Localityconstrained linear coding for image classification. CVPR, 2010.   \n[34] Jason Weston, Samy Bengio, and Nicolas Usunier. Wsabie: Scaling up to large vocabulary image annotation. In IJCAI, 2011.   \n[35] Jianxiong Xiao, James Hays, Krista Ehinger, Aude Oliva, and Antonio Torralba. Sun database: Large-scale scene recognition from abbey to zoo. CVPR, 2010.   \n[36] Jianchao Yang, Kai Yu, Yihong Gong, and Thomas Huang. Linear spatial pyramid matching uisng sparse coding for image classification. CVPR, 2009.   \n[37] Matt Zeiler and Rob Fergus. Stochastic pooling for regularization of deep convolutional neural networks. ICLR, 2013. ",
+        "bbox": [
+            173,
+            465,
+            826,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            97,
+            828,
+            916
+        ],
+        "page_idx": 8
+    }
+]