Add files using upload-large-folder tool

parse/train/B1xsqj09Fm/B1xsqj09Fm.md

@@ -0,0 +1,492 @@
+# LARGE SCALE GAN TRAINING FORHIGH FIDELITY NATURAL IMAGE SYNTHESIS
+
+Andrew Brock∗ † Heriot-Watt University ajb5@hw.ac.uk
+
+Jeff Donahue†   
+DeepMind   
+jeffdonahue@google.com
+
+Karen Simonyan† DeepMind simonyan@google.com
+
+# ABSTRACT
+
+Despite recent progress in generative image modeling, successfully generating high-resolution, diverse samples from complex datasets such as ImageNet remains an elusive goal. To this end, we train Generative Adversarial Networks at the largest scale yet attempted, and study the instabilities specific to such scale. We find that applying orthogonal regularization to the generator renders it amenable to a simple “truncation trick,” allowing fine control over the trade-off between sample fidelity and variety by reducing the variance of the Generator’s input. Our modifications lead to models which set the new state of the art in class-conditional image synthesis. When trained on ImageNet at $1 2 8 \times 1 2 8$ resolution, our models (BigGANs) achieve an Inception Score (IS) of 166.5 and Frechet Inception Dis- ´ tance (FID) of 7.4, improving over the previous best IS of 52.52 and FID of 18.65.
+
+# 1 INTRODUCTION
+
+![](images/270fcbea08660596ca68cc3991827d5e9af5cd15489848fd6f1a73487aaf199d.jpg)  
+Figure 1: Class-conditional samples generated by our model.
+
+The state of generative image modeling has advanced dramatically in recent years, with Generative Adversarial Networks (GANs, Goodfellow et al. (2014)) at the forefront of efforts to generate highfidelity, diverse images with models learned directly from data. GAN training is dynamic, and sensitive to nearly every aspect of its setup (from optimization parameters to model architecture), but a torrent of research has yielded empirical and theoretical insights enabling stable training in a variety of settings. Despite this progress, the current state of the art in conditional ImageNet modeling (Zhang et al., 2018) achieves an Inception Score (Salimans et al., 2016) of 52.5, compared to 233 for real data.
+
+In this work, we set out to close the gap in fidelity and variety between images generated by GANs and real-world images from the ImageNet dataset. We make the following three contributions towards this goal:
+
+• We demonstrate that GANs benefit dramatically from scaling, and train models with two to four times as many parameters and eight times the batch size compared to prior art. We introduce two simple, general architectural changes that improve scalability, and modify a regularization scheme to improve conditioning, demonstrably boosting performance.
+
+• As a side effect of our modifications, our models become amenable to the “truncation trick,” a simple sampling technique that allows explicit, fine-grained control of the tradeoff between sample variety and fidelity.   
+We discover instabilities specific to large scale GANs, and characterize them empirically. Leveraging insights from this analysis, we demonstrate that a combination of novel and existing techniques can reduce these instabilities, but complete training stability can only be achieved at a dramatic cost to performance.
+
+Our modifications substantially improve class-conditional GANs. When trained on ImageNet at $1 2 8 \times 1 2 8$ resolution, our models (BigGANs) improve the state-of-the-art Inception Score (IS) and Frechet Inception Distance (FID) from 52.52 and 18.65 to 166.5 and 7.4 respectively. We also ´ successfully train BigGANs on ImageNet at $2 5 6 \times 2 5 6$ and $5 1 2 \times 5 1 2$ resolution, and achieve IS and FID of 232.5 and 8.1 at $2 5 6 \times 2 5 6$ and IS and FID of 241.5 and 11.5 at $5 1 2 \times 5 1 2$ . Finally, we train our models on an even larger dataset – JFT-300M – and demonstrate that our design choices transfer well from ImageNet. Code and weights for our pretrained generators are publicly available 1.
+
+# 2 BACKGROUND
+
+A Generative Adversarial Network (GAN) involves Generator $\mathbf { \Pi } ( \pmb { \mathsf { G } } )$ and Discriminator (D) networks whose purpose, respectively, is to map random noise to samples and discriminate real and generated samples. Formally, the GAN objective, in its original form (Goodfellow et al., 2014) involves finding a Nash equilibrium to the following two player min-max problem:
+
+$$
+\operatorname* { m i n } _ { G } \operatorname* { m a x } _ { D } \mathbb { E } _ { { x } \sim { q _ { \mathrm { d a t a } } } ( \boldsymbol { x } ) } [ \log D ( \boldsymbol { x } ) ] + \mathbb { E } _ { \boldsymbol { z } \sim p ( \boldsymbol { z } ) } [ \log ( 1 - D ( G ( \boldsymbol { z } ) ) ) ] ,
+$$
+
+where $z ~ \in ~ \mathbb { R } ^ { d _ { z } }$ is a latent variable drawn from distribution $p ( z )$ such as $\mathcal { N } ( 0 , I )$ or $\mathcal { U } [ - 1 , 1 ]$ . When applied to images, $\pmb { \mathsf { G } }$ and D are usually convolutional neural networks (Radford et al., 2016). Without auxiliary stabilization techniques, this training procedure is notoriously brittle, requiring finely-tuned hyperparameters and architectural choices to work at all.
+
+Much recent research has accordingly focused on modifications to the vanilla GAN procedure to impart stability, drawing on a growing body of empirical and theoretical insights (Nowozin et al., 2016; Sønderby et al., 2017; Fedus et al., 2018). One line of work is focused on changing the objective function (Arjovsky et al., 2017; Mao et al., 2016; Lim & Ye, 2017; Bellemare et al., 2017; Salimans et al., 2018) to encourage convergence. Another line is focused on constraining D through gradient penalties (Gulrajani et al., 2017; Kodali et al., 2017; Mescheder et al., 2018) or normalization (Miyato et al., 2018), both to counteract the use of unbounded loss functions and ensure D provides gradients everywhere to G.
+
+Of particular relevance to our work is Spectral Normalization (Miyato et al., 2018), which enforces Lipschitz continuity on D by normalizing its parameters with running estimates of their first singular values, inducing backwards dynamics that adaptively regularize the top singular direction. Relatedly Odena et al. (2018) analyze the condition number of the Jacobian of G and find that performance is dependent on G’s conditioning. Zhang et al. (2018) find that employing Spectral Normalization in $\pmb { \mathsf { G } }$ improves stability, allowing for fewer D steps per iteration. We extend on these analyses to gain further insight into the pathology of GAN training.
+
+Other works focus on the choice of architecture, such as SA-GAN (Zhang et al., 2018) which adds the self-attention block from (Wang et al., 2018) to improve the ability of both G and D to model global structure. ProGAN (Karras et al., 2018) trains high-resolution GANs in the single-class setting by training a single model across a sequence of increasing resolutions.
+
+In conditional GANs (Mirza & Osindero, 2014) class information can be fed into the model in various ways. In (Odena et al., 2017) it is provided to G by concatenating a 1-hot class vector to the noise vector, and the objective is modified to encourage conditional samples to maximize the corresponding class probability predicted by an auxiliary classifier. de Vries et al. (2017) and
+
+<table><tr><td rowspan=1 colspan=1>Batch</td><td rowspan=1 colspan=1>Ch.</td><td rowspan=1 colspan=1>Param (M)</td><td rowspan=1 colspan=1>Shared</td><td rowspan=1 colspan=1>Skip-z</td><td rowspan=1 colspan=1>Ortho.</td><td rowspan=1 colspan=1>Itr ×103</td><td rowspan=1 colspan=1>FID</td><td rowspan=1 colspan=2>IS</td></tr><tr><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>81.5</td><td rowspan=1 colspan=3>SA-GAN Baseline</td><td rowspan=1 colspan=1>1000</td><td rowspan=1 colspan=1>18.65</td><td rowspan=1 colspan=2>52.52</td></tr><tr><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>81.5</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>1000</td><td rowspan=1 colspan=1>15.30</td><td rowspan=1 colspan=1>58.77(±1.18)</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>1024</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>81.5</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>1000</td><td rowspan=1 colspan=1>14.88</td><td rowspan=1 colspan=1>63.03(±1.42)</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>2048</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>81.5</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>732</td><td rowspan=1 colspan=1>12.39</td><td rowspan=1 colspan=1>76.85(±3.83)</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>2048</td><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>173.5</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>295(±18)</td><td rowspan=1 colspan=1>9.54(±0.62)</td><td rowspan=1 colspan=1>92.98(±4.27)</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>2048</td><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>160.6</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>185(±11)</td><td rowspan=1 colspan=1>9.18(±0.13)</td><td rowspan=1 colspan=1>94.94(±1.32)</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>2048</td><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>158.3</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>152(±7)</td><td rowspan=1 colspan=1>8.73(±0.45)</td><td rowspan=1 colspan=2>98.76((±2.84)</td></tr><tr><td rowspan=1 colspan=1>2048</td><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>158.3</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>了</td><td rowspan=1 colspan=1>165(±13)</td><td rowspan=1 colspan=1>8.51(±0.32)</td><td rowspan=1 colspan=1>99.31(±2.10)</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>2048</td><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>71.3</td><td rowspan=1 colspan=1>了</td><td rowspan=1 colspan=1>了</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>371(±7)</td><td rowspan=1 colspan=1>10.48(±0.10)</td><td rowspan=1 colspan=1>86.90(±0.61)</td><td rowspan=1 colspan=1></td></tr></table>
+
+Table 1: Frechet Inception Distance (FID, lower is better) and Inception Score (IS, higher is better)´ for ablations of our proposed modifications. Batch is batch size, Param is total number of parameters, $C h$ . is the channel multiplier representing the number of units in each layer, Shared is using shared embeddings, Skip- $z$ is using skip connections from the latent to multiple layers, Ortho. is Orthogonal Regularization, and $I t r$ indicates if the setting is stable to $1 0 ^ { 6 }$ iterations, or it collapses at the given iteration. Other than rows 1-4, results are computed across 8 random initializations.
+
+Dumoulin et al. (2017) modify the way class conditioning is passed to G by supplying it with classconditional gains and biases in BatchNorm (Ioffe & Szegedy, 2015) layers. In Miyato & Koyama (2018), D is conditioned by using the cosine similarity between its features and a set of learned class embeddings as additional evidence for distinguishing real and generated samples, effectively encouraging generation of samples whose features match a learned class prototype.
+
+Objectively evaluating implicit generative models is difficult (Theis et al., 2015). A variety of works have proposed heuristics for measuring the sample quality of models without tractable likelihoods (Salimans et al., 2016; Heusel et al., 2017; Binkowski et al., 2018; Wu et al., 2017). Of these, ´ the Inception Score (IS, Salimans et al. (2016)) and Frechet Inception Distance (FID, Heusel et al. ´ (2017)) have become popular despite their notable flaws (Barratt & Sharma, 2018). We employ them as approximate measures of sample quality, and to enable comparison against previous work.
+
+# 3 SCALING UP GANS
+
+In this section, we explore methods for scaling up GAN training to reap the performance benefits of larger models and larger batches. As a baseline, we employ the SA-GAN architecture of Zhang et al. (2018), which uses the hinge loss (Lim & Ye, 2017; Tran et al., 2017) GAN objective. We provide class information to $\pmb { \mathsf { G } }$ with class-conditional BatchNorm (Dumoulin et al., 2017; de Vries et al., 2017) and to D with projection (Miyato & Koyama, 2018). The optimization settings follow Zhang et al. (2018) (notably employing Spectral Norm in G) with the modification that we halve the learning rates and take two D steps per G step. For evaluation, we employ moving averages of G’s weights following Karras et al. (2018); Mescheder et al. (2018); Yazc et al. (2018), with a decay of 0.9999. We use Orthogonal Initialization (Saxe et al., 2014), whereas previous works used $\dot { \mathcal { N } } ( 0 , 0 . 0 2 I )$ (Radford et al., 2016) or Xavier initialization (Glorot & Bengio, 2010). Each model is trained on 128 to 512 cores of a Google TPUv3 Pod (Google, 2018), and computes BatchNorm statistics in G across all devices, rather than per-device as is typical. We find progressive growing (Karras et al., 2018) unnecessary even for our $5 1 2 \times 5 1 2$ models. Additional details are in Appendix C.
+
+We begin by increasing the batch size for the baseline model, and immediately find tremendous benefits in doing so. Rows 1-4 of Table 1 show that simply increasing the batch size by a factor of 8 improves the state-of-the-art IS by $46 \%$ . We conjecture that this is a result of each batch covering more modes, providing better gradients for both networks. One notable side effect of this scaling is that our models reach better final performance in fewer iterations, but become unstable and undergo complete training collapse. We discuss the causes and ramifications of this in Section 4. For these experiments, we report scores from checkpoints saved just before collapse.
+
+We then increase the width (number of channels) in each layer by $50 \%$ , approximately doubling the number of parameters in both models. This leads to a further IS improvement of $21 \%$ , which we posit is due to the increased capacity of the model relative to the complexity of the dataset. Doubling the depth did not initially lead to improvement – we addressed this later in the BigGAN-deep model, which uses a different residual block structure.
+
+![](images/af3b2fb3d56d5c1d31eadbb19ed4d251b2758d90bc9a6792ec7dc55806f0b573.jpg)  
+Figure 2: (a) The effects of increasing truncation. From left to right, the threshold is set to 2, 1, 0.5, 0.04. (b) Saturation artifacts from applying truncation to a poorly conditioned model.
+
+We note that class embeddings $c$ used for the conditional BatchNorm layers in G contain a large number of weights. Instead of having a separate layer for each embedding (Miyato et al., 2018; Zhang et al., 2018), we opt to use a shared embedding, which is linearly projected to each layer’s gains and biases (Perez et al., 2018). This reduces computation and memory costs, and improves training speed (in number of iterations required to reach a given performance) by $37 \%$ . Next, we add direct skip connections (skip- $z$ ) from the noise vector $z$ to multiple layers of $\pmb { \mathsf { G } }$ rather than just the initial layer. The intuition behind this design is to allow $\pmb { \mathsf { G } }$ to use the latent space to directly influence features at different resolutions and levels of hierarchy. In BigGAN, this is accomplished by splitting $z$ into one chunk per resolution, and concatenating each chunk to the conditional vector $c$ which gets projected to the BatchNorm gains and biases. In BigGAN-deep, we use an even simpler design, concatenating the entire $z$ with the conditional vector without splitting it into chunks. Previous works (Goodfellow et al., 2014; Denton et al., 2015) have considered variants of this concept; our implementation is a minor modification of this design. Skip- $z$ provides a modest performance improvement of around $4 \%$ , and improves training speed by a further $18 \%$ .
+
+# 3.1 TRADING OFF VARIETY AND FIDELITY WITH THE TRUNCATION TRICK
+
+Unlike models which need to backpropagate through their latents, GANs can employ an arbitrary prior $p ( z )$ , yet the vast majority of previous works have chosen to draw $z$ from either $\mathcal { N } ( 0 , I )$ or $\mathcal { U } [ - 1 , 1 ]$ . We question the optimality of this choice and explore alternatives in Appendix E.
+
+Remarkably, our best results come from using a different latent distribution for sampling than was used in training. Taking a model trained with $z \sim \mathcal { N } ( 0 , I )$ and sampling $z$ from a truncated normal (where values which fall outside a range are resampled to fall inside that range) immediately provides a boost to IS and FID. We call this the Truncation Trick: truncating a $z$ vector by resampling the values with magnitude above a chosen threshold leads to improvement in individual sample quality at the cost of reduction in overall sample variety. Figure 2(a) demonstrates this: as the threshold is reduced, and elements of $z$ are truncated towards zero (the mode of the latent distribution), individual samples approach the mode of G’s output distribution. Related observations about this trade-off were made in (Marchesi, 2016; Pieters & Wiering, 2014).
+
+This technique allows fine-grained, post-hoc selection of the trade-off between sample quality and variety for a given G. Notably, we can compute FID and IS for a range of thresholds, obtaining the variety-fidelity curve reminiscent of the precision-recall curve (Figure 17). As IS does not penalize lack of variety in class-conditional models, reducing the truncation threshold leads to a direct increase in IS (analogous to precision). FID penalizes lack of variety (analogous to recall) but also rewards precision, so we initially see a moderate improvement in FID, but as truncation approaches zero and variety diminishes, the FID sharply drops. The distribution shift caused by sampling with different latents than those seen in training is problematic for many models. Some of our larger models are not amenable to truncation, producing saturation artifacts (Figure 2(b)) when fed truncated noise. To counteract this, we seek to enforce amenability to truncation by conditioning G to be smooth, so that the full space of $z$ will map to good output samples. For this, we turn to Orthogonal Regularization (Brock et al., 2017), which directly enforces the orthogonality condition:
+
+$$
+R _ { \beta } ( W ) = \beta \| W ^ { \top } W - I \| _ { \mathrm { F } } ^ { 2 } ,
+$$
+
+where $W$ is a weight matrix and $\beta$ a hyperparameter. This regularization is known to often be too limiting (Miyato et al., 2018), so we explore several variants designed to relax the constraint while still imparting the desired smoothness to our models. The version we find to work best removes the diagonal terms from the regularization, and aims to minimize the pairwise cosine similarity between filters but does not constrain their norm:
+
+$$
+\begin{array} { r } { R _ { \beta } ( W ) = \beta \| W ^ { \top } W \odot ( \mathbf { 1 } - I ) \| _ { \mathrm { F } } ^ { 2 } , } \end{array}
+$$
+
+where 1 denotes a matrix with all elements set to 1. We sweep $\beta$ values and select $1 0 ^ { - 4 }$ , finding this small added penalty sufficient to improve the likelihood that our models will be amenable to truncation. Across runs in Table 1, we observe that without Orthogonal Regularization, only $16 \%$ of models are amenable to truncation, compared to $60 \%$ when trained with Orthogonal Regularization.
+
+# 3.2 SUMMARY
+
+We find that current GAN techniques are sufficient to enable scaling to large models and distributed, large-batch training. We find that we can dramatically improve the state of the art and train models up to $5 1 2 \times 5 1 2$ resolution without need for explicit multiscale methods like Karras et al. (2018). Despite these improvements, our models undergo training collapse, necessitating early stopping in practice. In the next two sections we investigate why settings which were stable in previous works become unstable when applied at scale.
+
+# 4 ANALYSIS
+
+![](images/502a56f6b72e5570a6830eaed4026d0a34c5f9b723420e1b50265ebd6956b406.jpg)  
+Figure 3: A typical plot of the first singular value $\sigma _ { 0 }$ in the layers of G (a) and D (b) before Spectral Normalization. Most layers in G have well-behaved spectra, but without constraints a small subset grow throughout training and explode at collapse. D’s spectra are noisier but otherwise betterbehaved. Colors from red to violet indicate increasing depth.
+
+# 4.1 CHARACTERIZING INSTABILITY: THE GENERATOR
+
+Much previous work has investigated GAN stability from a variety of analytical angles and on toy problems, but the instabilities we observe occur for settings which are stable at small scale, necessitating direct analysis at large scale. We monitor a range of weight, gradient, and loss statistics during training, in search of a metric which might presage the onset of training collapse, similar to (Odena et al., 2018). We found the top three singular values $\sigma _ { 0 } , \sigma _ { 1 } , \sigma _ { 2 }$ of each weight matrix to be the most informative. They can be efficiently computed using the Alrnoldi iteration method (Golub & der Vorst, 2000), which extends the power iteration method, used in Miyato et al. (2018), to estimation of additional singular vectors and values. A clear pattern emerges, as can be seen in Figure 3(a) and Appendix F: most G layers have well-behaved spectral norms, but some layers (typically the first layer in G, which is over-complete and not convolutional) are ill-behaved, with spectral norms that grow throughout training and explode at collapse.
+
+To ascertain if this pathology is a cause of collapse or merely a symptom, we study the effects of imposing additional conditioning on $\pmb { \mathsf { G } }$ to explicitly counteract spectral explosion. First, we directly regularize the top singular values $\sigma _ { 0 }$ of each weight, either towards a fixed value $\sigma _ { r e g }$ or towards some ratio $r$ of the second singular value, $r \cdot s g ( \sigma _ { 1 } )$ (with $s g$ the stop-gradient operation to prevent the regularization from increasing $\sigma _ { 1 }$ ). Alternatively, we employ a partial singular value decomposition to instead clamp $\sigma _ { 0 }$ . Given a weight $W$ , its first singular vectors $u _ { 0 }$ and $v _ { 0 }$ , and $\sigma _ { c l a m p }$ the value to which the $\sigma _ { 0 }$ will be clamped, our weights become:
+
+$$
+W = W - \operatorname* { m a x } ( 0 , \sigma _ { 0 } - \sigma _ { c l a m p } ) v _ { 0 } u _ { 0 } ^ { \top } ,
+$$
+
+where $\sigma _ { c l a m p }$ is set to either $\sigma _ { r e g }$ or $r \cdot s g ( \sigma _ { 1 } )$ . We observe that both with and without Spectral Normalization these techniques have the effect of preventing the gradual increase and explosion of either $\sigma _ { 0 }$ or $\frac { \sigma _ { 0 } } { \sigma _ { 1 } }$ , but even though in some cases they mildly improve performance, no combination prevents training collapse. This evidence suggests that while conditioning $\pmb { \mathsf { G } }$ might improve stability, it is insufficient to ensure stability. We accordingly turn our attention to $\mathbf { D }$ .
+
+# 4.2 CHARACTERIZING INSTABILITY: THE DISCRIMINATOR
+
+As with $\pmb { \mathsf { G } }$ , we analyze the spectra of D’s weights to gain insight into its behavior, then seek to stabilize training by imposing additional constraints. Figure 3(b) displays a typical plot of $\sigma _ { 0 }$ for $\mathbf { D }$ (with further plots in Appendix F). Unlike G, we see that the spectra are noisy, $\frac { \sigma _ { 0 } } { \sigma _ { 1 } }$ is well-behaved, and the singular values grow throughout training but only jump at collapse, instead of exploding.
+
+The spikes in D’s spectra might suggest that it periodically receives very large gradients, but we observe that the Frobenius norms are smooth (Appendix F), suggesting that this effect is primarily concentrated on the top few singular directions. We posit that this noise is a result of optimization through the adversarial training process, where $\pmb { \mathsf { G } }$ periodically produces batches which strongly perturb D . If this spectral noise is causally related to instability, a natural counter is to employ gradient penalties, which explicitly regularize changes in $\mathbf { D }$ ’s Jacobian. We explore the $R _ { 1 }$ zero-centered gradient penalty from Mescheder et al. (2018):
+
+$$
+R _ { 1 } : = \frac { \gamma } { 2 } \mathbb { E } _ { p _ { D } ( x ) } \left[ \| \nabla D ( x ) \| _ { F } ^ { 2 } \right] .
+$$
+
+With the default suggested $\gamma$ strength of 10, training becomes stable and improves the smoothness and boundedness of spectra in both $\pmb { \mathsf { G } }$ and D, but performance severely degrades, resulting in a $45 \%$ reduction in IS. Reducing the penalty partially alleviates this degradation, but results in increasingly ill-behaved spectra; even with the penalty strength reduced to 1 (the lowest strength for which sudden collapse does not occur) the IS is reduced by $20 \%$ . Repeating this experiment with various strengths of Orthogonal Regularization, DropOut (Srivastava et al., 2014), and L2 (See Appendix I for details), reveals similar behaviors for these regularization strategies: with high enough penalties on D, training stability can be achieved, but at a substantial cost to performance.
+
+We also observe that D’s loss approaches zero during training, but undergoes a sharp upward jump at collapse (Appendix F). One possible explanation for this behavior is that D is overfitting to the training set, memorizing training examples rather than learning some meaningful boundary between real and generated images. As a simple test for D’s memorization (related to Gulrajani et al. (2017)), we evaluate uncollapsed discriminators on the ImageNet training and validation sets, and measure what percentage of samples are classified as real or generated. While the training accuracy is consistently above $98 \%$ , the validation accuracy falls in the range of $50 \%$ , no better than random guessing (regardless of regularization strategy). This confirms that D is indeed memorizing the training set; we deem this in line with D’s role, which is not explicitly to generalize, but to distill the training data and provide a useful learning signal for G. Additional experiments and discussion are provided in Appendix G.
+
+# 4.3 SUMMARY
+
+We find that stability does not come solely from $\pmb { \mathsf { G } }$ or $\mathbf { D }$ , but from their interaction through the adversarial training process. While the symptoms of their poor conditioning can be used to track and identify instability, ensuring reasonable conditioning proves necessary for training but insufficient to prevent eventual training collapse. It is possible to enforce stability by strongly constraining D, but doing so incurs a dramatic cost in performance. With current techniques, better final performance can be achieved by relaxing this conditioning and allowing collapse to occur at the later stages of training, by which time a model is sufficiently trained to achieve good results.
+
+Table 2: Evaluation of models at different resolutions. We report scores without truncation (Column 3), scores at the best FID (Column 4), scores at the IS of validation data (Column 5), and scores at the max IS (Column 6). Standard deviations are computed over at least three random initializations.   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Res.</td><td rowspan=1 colspan=1>FID/IS</td><td rowspan=1 colspan=1>(min FID)/ IS</td><td rowspan=1 colspan=1>FID/ (valid IS)</td><td rowspan=1 colspan=1>FID/ (max IS)</td></tr><tr><td rowspan=1 colspan=1>SN-GAN</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>27.62/36.80</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td></tr><tr><td rowspan=1 colspan=1>SA-GAN</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>18.65/52.52</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td></tr><tr><td rowspan=1 colspan=1>BigGAN</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>8.7± .6/98.8±3</td><td rowspan=1 colspan=1>7.7 ± 2/126.5±0</td><td rowspan=1 colspan=1>9.6±.4/166.3±1</td><td rowspan=1 colspan=1>25 ±2/206± 2</td></tr><tr><td rowspan=1 colspan=1>BigGAN</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>8.7 ± 1/142.3± 2</td><td rowspan=1 colspan=1>7.7 ± .1/178.0±5</td><td rowspan=1 colspan=1>9.3 ± 3/233.1 ± 1</td><td rowspan=1 colspan=1>25±5/291±4</td></tr><tr><td rowspan=1 colspan=1>BigGAN</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>8.1/144.2</td><td rowspan=1 colspan=1>7.6/170.3</td><td rowspan=1 colspan=1>11.8/241.4</td><td rowspan=1 colspan=1>27.0/275</td></tr><tr><td rowspan=1 colspan=1>BigGAN-deep</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>5.7 ± 3/124.5± 2</td><td rowspan=1 colspan=1>6.3± 3/148.1±4</td><td rowspan=1 colspan=1>7.4 ± .6/166.5±1</td><td rowspan=1 colspan=1>25 ±2/253±11</td></tr><tr><td rowspan=1 colspan=1>BigGAN-deep</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>6.9 ± .2/171.4± 2</td><td rowspan=1 colspan=1>7.0±.1/202.6± 2</td><td rowspan=1 colspan=1>8.1 ± 1/232.5 ± 2</td><td rowspan=1 colspan=1>27±8/317±6</td></tr><tr><td rowspan=1 colspan=1>BigGAN-deep</td><td rowspan=1 colspan=1>512</td><td rowspan=1 colspan=1>7.5/152.8</td><td rowspan=1 colspan=1>7.7/181.4</td><td rowspan=1 colspan=1>11.5/241.5</td><td rowspan=1 colspan=1>39.7/298</td></tr></table>
+
+# 5 EXPERIMENTS
+
+![](images/f271d15f2d0a74e8060b04ea11570b5b75bf602bea16febd370625b001252104.jpg)  
+Figure 4: Samples from our BigGAN model with truncation threshold 0.5 (a-c) and an example of class leakage in a partially trained model (d).
+
+# 5.1 EVALUATION ON IMAGENET
+
+We evaluate our models on ImageNet ILSVRC 2012 (Russakovsky et al., 2015) at $1 2 8 \times 1 2 8$ , $2 5 6 \times 2 5 6$ , and $5 1 2 \times 5 1 2$ resolutions, employing the settings from Table 1, row 8. The samples generated by our models are presented in Figure 4, with additional samples in Appendix A, and online 2. We report IS and FID in Table 2. As our models are able to trade sample variety for quality, it is unclear how best to compare against prior art; we accordingly report values at three settings, with complete curves in Appendix D. First, we report the FID/IS values at the truncation setting which attains the best FID. Second, we report the FID at the truncation setting for which our model’s IS is the same as that attained by the real validation data, reasoning that this is a passable measure of maximum sample variety achieved while still achieving a good level of “objectness.” Third, we report FID at the maximum IS achieved by each model, to demonstrate how much variety must be traded off to maximize quality. In all three cases, our models outperform the previous state-of-the-art IS and FID scores achieved by Miyato et al. (2018) and Zhang et al. (2018).
+
+In addition to the BigGAN model introduced in the first version of the paper and used in the majority of experiments (unless otherwise stated), we also present a 4x deeper model (BigGAN-deep) which uses a different configuration of residual blocks. As can be seen from Table 2, BigGAN-deep substantially outperforms BigGAN across all resolutions and metrics. This confirms that our findings extend to other architectures, and that increased depth leads to improvement in sample quality. Both BigGAN and BigGAN-deep architectures are described in Appendix B.
+
+Table 3: BigGAN results on JFT-300M at $2 5 6 \times 2 5 6$ resolution. The $F I D$ and $I S$ columns report these scores given by the JFT-300M-trained Inception v2 classifier with noise distributed as $z \sim \mathcal { N } ( 0 , I )$ (non-truncated). The $\left( m i n F I D \right) / I S$ and $F I D / ( m a x I S )$ columns report scores at the best FID and IS from a sweep across truncated noise distributions ranging from $\sigma = 0$ to $\sigma = 2$ . Images from the JFT-300M validation set have an IS of 50.88 and FID of 1.94.   
+
+<table><tr><td rowspan=1 colspan=1>Ch.</td><td rowspan=1 colspan=1>Param (M)</td><td rowspan=1 colspan=1>Shared</td><td rowspan=1 colspan=1>Skip-z</td><td rowspan=1 colspan=1>Ortho.</td><td rowspan=1 colspan=1>FID</td><td rowspan=1 colspan=1>IS</td><td rowspan=1 colspan=1>(min FID)/ IS</td><td rowspan=1 colspan=1>FID /(max IS)</td></tr><tr><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>317.1</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>48.38</td><td rowspan=1 colspan=1>23.27</td><td rowspan=1 colspan=1>48.6/23.1</td><td rowspan=1 colspan=1>49.1/23.9</td></tr><tr><td rowspan=1 colspan=1>64</td><td rowspan=1 colspan=1>99.4</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>23.48</td><td rowspan=1 colspan=1>24.78</td><td rowspan=1 colspan=1>22.4/21.0</td><td rowspan=1 colspan=1>60.9/35.8</td></tr><tr><td rowspan=1 colspan=1>96</td><td rowspan=1 colspan=1>207.9</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>了</td><td rowspan=1 colspan=1>\</td><td rowspan=1 colspan=1>18.84</td><td rowspan=1 colspan=1>27.86</td><td rowspan=1 colspan=1>17.1/23.3</td><td rowspan=1 colspan=1>51.6/38.1</td></tr><tr><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>355.7</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>了</td><td rowspan=1 colspan=1>厂</td><td rowspan=1 colspan=1>13.75</td><td rowspan=1 colspan=1>30.61</td><td rowspan=1 colspan=1>13.0/28.0</td><td rowspan=1 colspan=1>46.2/47.8</td></tr></table>
+
+Our observation that D overfits to the training set, coupled with our model’s sample quality, raises the obvious question of whether or not G simply memorizes training points. To test this, we perform class-wise nearest neighbors analysis in pixel space and the feature space of pre-trained classifier networks (Appendix A). In addition, we present both interpolations between samples and class-wise interpolations (where $z$ is held constant) in Figures 8 and 9. Our model convincingly interpolates between disparate samples, and the nearest neighbors for its samples are visually distinct, suggesting that our model does not simply memorize training data.
+
+We note that some failure modes of our partially-trained models are distinct from those previously observed. Most previous failures involve local artifacts (Odena et al., 2016), images consisting of texture blobs instead of objects (Salimans et al., 2016), or the canonical mode collapse. We observe class leakage, where images from one class contain properties of another, as exemplified by Figure 4(d). We also find that many classes on ImageNet are more difficult than others for our model; our model is more successful at generating dogs (which make up a large portion of the dataset, and are mostly distinguished by their texture) than crowds (which comprise a small portion of the dataset and have more large-scale structure). Further discussion is available in Appendix A.
+
+# 5.2 ADDITIONAL EVALUATION ON JFT-300M
+
+To confirm that our design choices are effective for even larger and more complex and diverse datasets, we also present results of our system on a subset of JFT-300M (Sun et al., 2017). The full JFT-300M dataset contains 300M real-world images labeled with 18K categories. Since the category distribution is heavily long-tailed, we subsample the dataset to keep only images with the 8.5K most common labels. The resulting dataset contains 292M images – two orders of magnitude larger than ImageNet. For images with multiple labels, we sample a single label randomly and independently whenever an image is sampled. To compute IS and FID for the GANs trained on this dataset, we use an Inception v2 classifier (Szegedy et al., 2016) trained on this dataset. Quantitative results are presented in Table 3. All models are trained with batch size 2048. We compare an ablated version of our model – comparable to SA-GAN (Zhang et al., 2018) but with the larger batch size – against a “full” BigGAN model that makes uses of all of the techniques applied to obtain the best results on ImageNet (shared embedding, skip- $z$ , and orthogonal regularization). Our results show that these techniques substantially improve performance even in the setting of this much larger dataset at the same model capacity (64 base channels). We further show that for a dataset of this scale, we see significant additional improvements from expanding the capacity of our models to 128 base channels, while for ImageNet GANs that additional capacity was not beneficial.
+
+In Figure 19 (Appendix D), we present truncation plots for models trained on this dataset. Unlike for ImageNet, where truncation limits of $\sigma \approx 0$ tend to produce the highest fidelity scores, IS is typically maximized for our JFT-300M models when the truncation value $\sigma$ ranges from 0.5 to 1. We suspect that this is at least partially due to the intra-class variability of JFT-300M labels, as well as the relative complexity of the image distribution, which includes images with multiple objects at a variety of scales. Interestingly, unlike models trained on ImageNet, where training tends to collapse without heavy regularization (Section 4), the models trained on JFT-300M remain stable over many hundreds of thousands of iterations. This suggests that moving beyond ImageNet to larger datasets may partially alleviate GAN stability issues.
+
+The improvement over the baseline GAN model that we achieve on this dataset without changes to the underlying models or training and regularization techniques (beyond expanded capacity) demonstrates that our findings extend from ImageNet to datasets with scale and complexity thus far unprecedented for generative models of images.
+
+# 6 CONCLUSION
+
+We have demonstrated that Generative Adversarial Networks trained to model natural images of multiple categories highly benefit from scaling up, both in terms of fidelity and variety of the generated samples. As a result, our models set a new level of performance among ImageNet GAN models, improving on the state of the art by a large margin. We have also presented an analysis of the training behavior of large scale GANs, characterized their stability in terms of the singular values of their weights, and discussed the interplay between stability and performance.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Kai Arulkumaran, Matthias Bauer, Peter Buchlovsky, Jeffrey Defauw, Sander Dieleman, Ian Goodfellow, Ariel Gordon, Karol Gregor, Dominik Grewe, Chris Jones, Jacob Menick, Augustus Odena, Suman Ravuri, Ali Razavi, Mihaela Rosca, and Jeff Stanway.
+
+# REFERENCES
+
+Mart´ın Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, Manjunath Kudlur, Josh Levenberg, Rajat Monga, Sherry Moore, Derek Murray, Benoit Steiner, Paul Tucker, Vijay Vasudevan, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: A system for large-scale machine learning. In OSDI, 2016.
+
+Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein generative adversarial networks. ´ In ICML, 2017.
+
+Shane Barratt and Rishi Sharma. A note on the Inception Score. In arXiv preprint arXiv:1801.01973, 2018.
+
+Marc G. Bellemare, Ivo Danihelka, Will Dabney, Shakir Mohamed, Balaji Lakshminarayanan, Stephan Hoyer, and Remi Munos. The Cramer distance as a solution to biased Wasserstein gra- ´ dients. In arXiv preprint arXiv:1705.10743, 2017.
+
+Mikolaj Binkowski, Dougal J. Sutherland, Michael Arbel, and Arthur Gretton. Demystifying MMD ´ GANs. In ICLR, 2018.
+
+Andrew Brock, Theodore Lim, J.M. Ritchie, and Nick Weston. Neural photo editing with introspective adversarial networks. In ICLR, 2017.
+
+Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. In NIPS, 2016.
+
+Harm de Vries, Florian Strub, Jer´ emie Mary, Hugo Larochelle, Olivier Pietquin, and Aaron ´ Courville. Modulating early visual processing by language. In NIPS, 2017.
+
+Emily Denton, Soumith Chintala, Arthur Szlam, and Rob Fergus. Deep generative image models using a laplacian pyramid of adversarial networks. In NIPS, 2015.
+
+Vincent Dumoulin, Jonathon Shlens, and Manjunath Kudlur. A learned representation for artistic style. In ICLR, 2017.
+
+William Fedus, Mihaela Rosca, Balaji Lakshminarayanan, Andrew M. Dai, Shakir Mohamed, and Ian Goodfellow. Many paths to equilibrium: GANs do not need to decrease a divergence at every step. In ICLR, 2018.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In AISTATS, 2010.
+
+Gene Golub and Henk Van der Vorst. Eigenvalue computation in the 20th century. Journal of Computational and Applied Mathematics, 123:35–65, 2000.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, and Aaron Courville Yoshua Bengio. Generative adversarial nets. In NIPS, 2014.
+
+Google. Cloud TPUs. https://cloud.google.com/tpu/, 2018.
+
+Ishaan Gulrajani, Faruk Ahmed, Mart´ın Arjovsky, Vincent Dumoulin, and Aaron C. Courville. Improved training of Wasserstein GANs. In NIPS, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, Gunter Klambauer, and ¨ Sepp Hochreiter. GANs trained by a two time-scale update rule converge to a local nash equilibrium. In NIPS, 2017.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.
+
+Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of GANs for improved quality, stability, and variation. In ICLR, 2018.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2014.
+
+Naveen Kodali, Jacob Abernethy, James Hays, and Zsolt Kira. On convergence and stability of GANs. In arXiv preprint arXiv:1705.07215, 2017.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Jae Hyun Lim and Jong Chul Ye. Geometric GAN. In arXiv preprint arXiv:1705.02894, 2017.
+
+Xudong Mao, Qing Li, Haoran Xie, Raymond Y. K. Lau, and Zhen Wang. Least squares generative adversarial networks. In arXiv preprint arXiv:1611.04076, 2016.
+
+Marco Marchesi. Megapixel size image creation using generative adversarial networks. In arXiv preprint arXiv:1706.00082, 2016.
+
+Lars Mescheder, Andreas Geiger, and Sebastian Nowozin. Which training methods for GANs do actually converge? In ICML, 2018.
+
+Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. In arXiv preprint arXiv:1411.1784, 2014.
+
+Takeru Miyato and Masanori Koyama. cGANs with projection discriminator. In ICLR, 2018.
+
+Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. In ICLR, 2018.
+
+Sebastian Nowozin, Botond Cseke, and Ryota Tomioka. f-GAN: Training generative neural samplers using variational divergence minimization. In NIPS, 2016.
+
+Augustus Odena, Vincent Dumoulin, and Chris Olah. Deconvolution and checkerboard artifacts. Distill, 2016.
+
+Augustus Odena, Christopher Olah, and Jonathon Shlens. Conditional image synthesis with auxiliary classifier GANs. In ICML, 2017.
+
+Augustus Odena, Jacob Buckman, Catherine Olsson, Tom B. Brown, Christopher Olah, Colin Raffel, and Ian Goodfellow. Is generator conditioning causally related to GAN performance? In ICML, 2018.
+
+Ethan Perez, Florian Strub, Harm de Vries, Vincent Dumoulin, and Aaron Courville. FiLM: Visual reasoning with a general conditioning layer. In AAAI, 2018.
+
+Mathijs Pieters and Marco Wiering. Comparing generative adversarial network techniques for image creation and modificatio. In arXiv preprint arXiv:1803.09093, 2014.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. In ICLR, 2016.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, and Michael Bernstein. ImageNet large scale visual recognition challenge. IJCV, 115:211–252, 2015.
+
+Tim Salimans and Diederik Kingma. Weight normalization: A simple reparameterization to accelerate training of deep neural networks. In NIPS, 2016.
+
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training GANs. In NIPS, 2016.
+
+Tim Salimans, Han Zhang, Alec Radford, and Dimitris Metaxas. Improving GANs using optimal transport. In ICLR, 2018.
+
+Andrew Saxe, James McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. In ICLR, 2014.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.
+
+Casper Kaae Sønderby, Jose Caballero, Lucas Theis, Wenzhe Shi, and Ferenc Huszr. Amortised map inference for image super-resolution. In ICLR, 2017.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. JMLR, 15:1929–1958, 2014.
+
+Chen Sun, Abhinav Shrivastava, Saurabh Singh, and Abhinav Gupta. Revisiting unreasonable effectiveness of data in deep learning era. In ICCV, 2017.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In CVPR, 2016.
+
+Lucas Theis, Aaron van den Oord, and Matthias Bethge. A note on the evaluation of generative ¨ models. In arXiv preprint arXiv:1511.01844, 2015.
+
+Dustin Tran, Rajesh Ranganath, and David M. Blei. Hierarchical implicit models and likelihood-free variational inference. In NIPS, 2017.
+
+Xiaolong Wang, Ross B. Girshick, Abhinav Gupta, and Kaiming He. Non-local neural networks. In CVPR, 2018.
+
+Yuhuai Wu, Yuri Burda, Ruslan Salakhutdinov, and Roger B. Grosse. On the quantitative analysis of decoder-based generative models. In ICLR, 2017.
+
+Yasin Yazc, Chuan-Sheng Foo, Stefan Winkler, Kim-Hui Yap, Georgios Piliouras, and Vijay Chandrasekhar. The unusual effectiveness of averaging in gan training. In arXiv preprint arXiv:1806.04498, 2018.
+
+Han Zhang, Ian Goodfellow, Dimitris Metaxas, and Augustus Odena. Self-attention generative adversarial networks. In arXiv preprint arXiv:1805.08318, 2018.
+
+# APPENDIX A ADDITIONAL SAMPLES, INTERPOLATIONS, AND NEAREST NEIGHBORS FROM IMAGENET MODELS
+
+![](images/c937cff9a102fa41fd24eaf0fcd2862d26bd8123d6302fc33a0b8a051fd22e9a.jpg)  
+Figure 5: Samples generated by our BigGAN model at $2 5 6 \times 2 5 6$ resolution.
+
+![](images/a09dd6b24745984ef274c140c95e2529143c3bef7b3628e6b318931946de9151.jpg)  
+Figure 6: Samples generated by our BigGAN model at $5 1 2 \times 5 1 2$ resolution.
+
+![](images/3b31ec9c5af382db6ef448fe678f96feb9dd195d37d95e3b227aabc9d5a6f2d8.jpg)  
+Figure 7: Comparing easy classes (a) with difficult classes (b) at $5 1 2 \times 5 1 2$ . Classes such as dogs which are largely textural, and common in the dataset, are far easier to model than classes involving unaligned human faces or crowds. Such classes are more dynamic and structured, and often have details to which human observers are more sensitive. The difficulty of modeling global structure is further exacerbated when producing high-resolution images, even with non-local blocks.
+
+![](images/ee31ee196531a2e78a78c70a84cafae0fdba75233deee53523946002c03d6f89.jpg)  
+Figure 8: Interpolations between $z , c$ pairs.
+
+![](images/69297aec9a83dfd503986d37c03c48079d4f99380ff3bf8979c68fe499fe5747.jpg)  
+Figure 9: Interpolations between $c$ with $z$ held constant. Pose semantics are frequently maintained between endpoints (particularly in the final row). Row 2 demonstrates that grayscale is encoded in the joint $z , c$ space, rather than in $z$ .
+
+![](images/5a815d5a4b6289158f66ae7762b269006bab4e81e0503c5405d9f08c288ff3d1.jpg)  
+Figure 10: Nearest neighbors in VGG-16-fc7 (Simonyan & Zisserman, 2015) feature space. The generated image is in the top left.
+
+![](images/27628e9bd88e98a62108a2713499de794a775ef9c6b30ac2d4fe6583f4c813a6.jpg)  
+Figure 11: Nearest neighbors in ResNet-50-avgpool (He et al., 2016) feature space. The generated image is in the top left.
+
+![](images/101855a27a911cf056a22285fdf9626fb0348d3856b0ebff9b9a827ce6c5330c.jpg)  
+Figure 12: Nearest neighbors in pixel space. The generated image is in the top left.
+
+![](images/bf0c8abfcba5b34a163e07feb3d55df0054d59c4d0aac85eb26f11ba10979f3f.jpg)  
+Figure 13: Nearest neighbors in VGG-16-fc7 (Simonyan & Zisserman, 2015) feature space. The generated image is in the top left.
+
+![](images/d9d7c022d3881e4fe6f54a966089c4d04d7e6a2e8d75ed4adca2a63f4e760f43.jpg)  
+Figure 14: Nearest neighbors in ResNet-50-avgpool (He et al., 2016) feature space. The generated image is in the top left.
+
+# APPENDIX B ARCHITECTURAL DETAILS
+
+In the BigGAN model (Figure 15), we use the ResNet (He et al., 2016) GAN architecture of (Zhang et al., 2018), which is identical to that used by (Miyato et al., 2018), but with the channel pattern in D modified so that the number of filters in the first convolutional layer of each block is equal to the number of output filters (rather than the number of input filters, as in Miyato et al. (2018); Gulrajani et al. (2017)). We use a single shared class embedding in G, and skip connections for the latent vector $z$ (skip- $z$ ). In particular, we employ hierarchical latent spaces, so that the latent vector $z$ is split along its channel dimension into chunks of equal size (20-D in our case), and each chunk is concatenated to the shared class embedding and passed to a corresponding residual block as a conditioning vector. The conditioning of each block is linearly projected to produce per-sample gains and biases for the BatchNorm layers of the block. The bias projections are zero-centered, while the gain projections are centered at 1. Since the number of residual blocks depends on the image resolution, the full dimensionality of $z$ is 120 for $1 2 8 \times 1 2 8$ , 140 for $2 5 6 \times 2 5 6$ , and 160 for $5 1 2 \times 5 1 2$ images.
+
+The BigGAN-deep model (Figure 16) differs from BigGAN in several aspects. It uses a simpler variant of skip- $z$ conditioning: instead of first splitting $z$ into chunks, we concatenate the entire $z$ with the class embedding, and pass the resulting vector to each residual block through skip connections. BigGAN-deep is based on residual blocks with bottlenecks (He et al., 2016), which incorporate two additional $1 \times 1$ convolutions: the first reduces the number of channels by a factor of 4 before the more expensive $3 \times 3$ convolutions; the second produces the required number of output channels. While BigGAN relies on $1 \times 1$ convolutions in the skip connections whenever the number of channels needs to change, in BigGAN-deep we use a different strategy aimed at preserving identity throughout the skip connections. In G, where the number of channels needs to be reduced, we simply retain the first group of channels and drop the rest to produce the required number of channels. In D, where the number of channels should be increased, we pass the input channels unperturbed, and concatenate them with the remaining channels produced by a $1 \times 1$ convolution. As far as the network configuration is concerned, the discriminator is an exact reflection of the generator. There are two blocks at each resolution (BigGAN uses one), and as a result BigGAN-deep is four times deeper than BigGAN. Despite their increased depth, the BigGAN-deep models have significantly fewer parameters mainly due to the bottleneck structure of their residual blocks. For example, the $1 2 8 \times 1 2 8$ BigGAN-deep G and D have 50.4M and $3 4 . 6 \mathbf { M }$ parameters respectively, while the corresponding original BigGAN models have $7 0 . 4 \mathbf { M }$ and $8 8 . 0 \mathbf { M }$ parameters. All BigGAN-deep models use attention at $6 4 \times 6 4$ resolution, channel width multiplier $c h = 1 2 8$ , and $z \in \mathbb { R } ^ { 1 2 8 }$ .
+
+![](images/e91203f16394fcf7e7e3a3ed66b2201a7bf795fd271993199c3106bd1475e2c9.jpg)  
+Figure 15: (a) A typical architectural layout for BigGAN’s G; details are in the following tables. (b) A Residual Block (ResBlock up) in BigGAN’s G. (c) A Residual Block (ResBlock down) in BigGAN’s D.
+
+![](images/d3f46a5ed7e9b5314ebf6827cd90e54ad8e0736198dd2901ef01b36c676a084e.jpg)  
+Figure 16: (a) A typical architectural layout for BigGAN-deep’s G; details are in the following tables. (b) A Residual Block (ResBlock up) in BigGAN-deep’s G. (c) A Residual Block (ResBlock down) in BigGAN-deep’s D. A ResBlock (without up or down) in BigGAN-deep does not include the Upsample or Average Pooling layers, and has identity skip connections.
+
+Table 4: BigGAN architecture for $1 2 8 \times 1 2 8$ images. ch represents the channel width multiplier in each network from Table 1.   
+
+<table><tr><td rowspan=1 colspan=1>z ∈ R120 ~N(0,I)Embed(y)∈R128</td></tr><tr><td rowspan=1 colspan=1>Linear (20+128)→4×4×16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlockup 16ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 8ch → 4ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 4ch → 2ch</td></tr><tr><td rowspan=1 colspan=1>Non-Local Block (64 × 64)</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 2ch → ch</td></tr><tr><td rowspan=1 colspan=1>BN,ReLU,3 ×3 Conv ch →3</td></tr><tr><td rowspan=1 colspan=1>Tanh</td></tr><tr><td rowspan=1 colspan=1>(a)Generator</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>RGB image x ∈ R128×128×3</td></tr><tr><td rowspan=1 colspan=1>ResBlock down ch →2ch</td></tr><tr><td rowspan=1 colspan=1>Non-Local Block (64 × 64)</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 2ch → 4ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 4ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlockdown 8ch→16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlockdown16ch→16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ReLU, Global sum pooling</td></tr><tr><td rowspan=1 colspan=1>Embed(y)·h + (linear→1)</td></tr><tr><td rowspan=1 colspan=1>(b）Discriminator</td></tr></table>
+
+Table 5: BigGAN architecture for $2 5 6 \times 2 5 6$ images. Relative to the $1 2 8 \times 1 2 8$ architecture, we add an additional ResBlock in each network at $1 6 \times 1 6$ resolution, and move the non-local block in $\pmb { \mathsf { G } }$ to $1 2 8 \times 1 2 8$ resolution. Memory constraints prevent us from moving the non-local block in D.   
+
+<table><tr><td rowspan=1 colspan=1>z ∈ R140 ~N(0,I)Embed(y)∈R128</td></tr><tr><td rowspan=1 colspan=1>Linear(20+128)→4×4×16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 16ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 8ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 8ch →4ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 4ch -→ 2ch</td></tr><tr><td rowspan=1 colspan=1>Non-Local Block (128 × 128)</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 2ch →ch</td></tr><tr><td rowspan=1 colspan=1>BN,ReLU,3 ×3 Conv ch →3</td></tr><tr><td rowspan=1 colspan=1>Tanh</td></tr><tr><td rowspan=1 colspan=1>(a) Generator</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>RGB image x ∈ R256×256×3</td></tr><tr><td rowspan=1 colspan=1>ResBlock down ch → 2ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 2ch → 4ch</td></tr><tr><td rowspan=1 colspan=1>Non-Local Block (64 × 64)</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 4ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 8ch → 8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 8ch→16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ReLU, Global sum pooling</td></tr><tr><td rowspan=1 colspan=1>Embed(y)·h+ (linear→1)</td></tr><tr><td rowspan=1 colspan=1>(b）Discriminator</td></tr></table>
+
+Table 6: BigGAN architecture for $5 1 2 \times 5 1 2$ images. Relative to the $2 5 6 \times 2 5 6$ architecture, we add an additional ResBlock at the $5 1 2 \times 5 1 2$ resolution. Memory constraints force us to move the non-local block in both networks back to $6 4 \times 6 4$ resolution as in the $1 2 8 \times 1 2 8$ pixel setting.   
+
+<table><tr><td rowspan=1 colspan=1>z ∈ R160 ~N(0,I)Embed(y)∈R128</td></tr><tr><td rowspan=1 colspan=1>Linear(20+128)→4× 4× 16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 16ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 8ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 8ch → 4ch</td></tr><tr><td rowspan=1 colspan=1>Non-Local Block (64 × 64)</td></tr><tr><td rowspan=1 colspan=1>ResBlockup 4ch→2ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 2ch → ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up ch → ch</td></tr><tr><td rowspan=1 colspan=1>BN,ReLU,3 × 3 Conv ch → 3</td></tr><tr><td rowspan=1 colspan=1>Tanh</td></tr><tr><td rowspan=1 colspan=1>(a)Generator</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>RGB image x ∈ R512×512×3</td></tr><tr><td rowspan=1 colspan=1>ResBlock down ch → ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down ch →2ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 2ch → 4ch</td></tr><tr><td rowspan=1 colspan=1>Non-Local Block (64 × 64)</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 4ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 8ch → 8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 8ch→16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock16ch→16ch</td></tr><tr><td rowspan=1 colspan=1>ReLU, Global sum pooling</td></tr><tr><td rowspan=1 colspan=1>Embed(y)·h + (linear→1)</td></tr><tr><td rowspan=1 colspan=1>(b)Discriminator</td></tr></table>
+
+Table 7: BigGAN-deep architecture for $1 2 8 \times 1 2 8$ images.   
+
+<table><tr><td rowspan=1 colspan=1>z ∈ R128 ~ N(0,1)Embed(y) ∈R128</td></tr><tr><td rowspan=1 colspan=1>Linear (128+128)-→4×4 ×16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 16ch → 8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 8ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 8ch → 4ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 4ch →4ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 4ch → 2ch</td></tr><tr><td rowspan=1 colspan=1>Non-Local Block (64 × 64)</td></tr><tr><td rowspan=1 colspan=1>ResBlock 2ch→ 2ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 2ch → ch</td></tr><tr><td rowspan=1 colspan=1>BN,ReLU,3 ×3 Conv ch -→3</td></tr><tr><td rowspan=1 colspan=1>Tanh</td></tr><tr><td rowspan=1 colspan=1>(a）Generator</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>RGB image x ∈ R128×128×3</td></tr><tr><td rowspan=1 colspan=1>3 ×3Conv 3→ ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down ch → 2ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 2ch → 2ch</td></tr><tr><td rowspan=1 colspan=1>Non-Local Block (64 × 64)</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 2ch → 4ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 4ch→4ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 4ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 8ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 8ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock16ch→16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 16ch→16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ReLU, Global sum pooling</td></tr><tr><td rowspan=1 colspan=1>Embed(y)·h + (linear→1)</td></tr><tr><td rowspan=1 colspan=1>(b)Discriminator</td></tr></table>
+
+Table 8: BigGAN-deep architecture for $2 5 6 \times 2 5 6$ images.   
+
+<table><tr><td rowspan=1 colspan=1>z ∈R128 ~N(0,I)Embed(y) ∈R128</td></tr><tr><td rowspan=1 colspan=1>Linear(128+128)→4 × 4× 16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 16ch→16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 16ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 8ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 8ch → 8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 8ch → 8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 8ch →4ch</td></tr><tr><td rowspan=1 colspan=1>Non-Local Block (64 × 64)</td></tr><tr><td rowspan=1 colspan=1>ResBlock4ch→4ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 4ch → 2ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 2ch→ 2ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 2ch → ch</td></tr><tr><td rowspan=1 colspan=1>BN,ReLU,3 ×3 Conv ch →3</td></tr><tr><td rowspan=1 colspan=1>Tanh</td></tr><tr><td rowspan=1 colspan=1>(a) Generator</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>RGB image x ∈ R256×256×3</td></tr><tr><td rowspan=1 colspan=1>3 ×3Conv 3 →ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down ch → 2ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 2ch→2ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 2ch→4ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 4ch→4ch</td></tr><tr><td rowspan=1 colspan=1>Non-Local Block (64 × 64)</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 4ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 8ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 8ch→8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 8ch→ 8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 8ch→16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock16ch→16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock16ch→16ch</td></tr><tr><td rowspan=1 colspan=1>ReLU, Global sum pooling</td></tr><tr><td rowspan=1 colspan=1>Embed(y)·h + (linear→1)</td></tr></table>
+
+(b) Discriminator
+
+Table 9: BigGAN-deep architecture for $5 1 2 \times 5 1 2$ images.   
+
+<table><tr><td rowspan=1 colspan=1>zER128~N(0,I)Embed(y)∈R128</td></tr><tr><td rowspan=1 colspan=1>Linear (128+128)→4× 4×16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock16ch→16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlockup 16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 16ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 8ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 8ch → 8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 8ch→8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 8ch → 4ch</td></tr><tr><td rowspan=1 colspan=1>Non-Local Block (64 × 64)</td></tr><tr><td rowspan=1 colspan=1>ResBlock 4ch→4ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 4ch → 2ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 2ch →2ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up 2ch →ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock ch →ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock up ch → ch</td></tr><tr><td rowspan=1 colspan=1>BN,ReLU,3 ×3 Conv ch → 3</td></tr><tr><td rowspan=1 colspan=1>Tanh</td></tr><tr><td rowspan=1 colspan=1>(a)Generator</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>RGB image x ∈ R512×512×3</td></tr><tr><td rowspan=1 colspan=1>3 × 3Conv 3-→ ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down ch →ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock ch →ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down ch →2ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 2ch→2ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 2ch → 4ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 4ch→4ch</td></tr><tr><td rowspan=1 colspan=1>Non-Local Block (64 × 64)</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 4ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 8ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 8ch →8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 8ch→8ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 8ch →→16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock16ch→16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock down 16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ResBlock 16ch →16ch</td></tr><tr><td rowspan=1 colspan=1>ReLU, Global sum pooling</td></tr><tr><td rowspan=1 colspan=1>Embed(y)·h + (linear→1)</td></tr><tr><td rowspan=1 colspan=1>(b)Discriminator</td></tr></table>
+
+# APPENDIX C EXPERIMENTAL DETAILS
+
+Our basic setup follows SA-GAN (Zhang et al., 2018), and is implemented in TensorFlow (Abadi et al., 2016). We employ the architectures detailed in Appendix B, with non-local blocks inserted at a single stage in each network. Both G and D networks are initialized with Orthogonal Initialization (Saxe et al., 2014). We use Adam optimizer (Kingma & Ba, 2014) with $\beta _ { 1 } = 0$ and $\beta _ { 2 } = 0 . 9 9 9$ and a constant learning rate. For BigGAN models at all resolutions, we use $2 \cdot 1 0 ^ { - 4 }$ in D and $5 \cdot 1 0 ^ { - 5 } $ in G. For BigGAN-deep, we use the learning rate of $2 \cdot 1 0 ^ { - 4 }$ in $\mathbf { D }$ and $5 \cdot 1 0 ^ { - 5 } $ in $\pmb { \mathsf { G } }$ for $1 2 8 \times 1 2 8$ models, and $2 . 5 \cdot 1 0 ^ { - 5 }$ in both D and $\pmb { \mathsf { G } }$ for $2 5 6 \times 2 5 6$ and $5 1 2 \times 5 1 2$ models. We experimented with the number of D steps per G step (varying it from 1 to 6) and found that two D steps per $\pmb { \mathsf { G } }$ step gave the best results.
+
+We use an exponential moving average of the weights of G at sampling time, with a decay rate set to 0.9999. We employ cross-replica BatchNorm (Ioffe & Szegedy, 2015) in G, where batch statistics are aggregated across all devices, rather than a single device as in standard implementations. Spectral Normalization (Miyato et al., 2018) is used in both G and D, following SA-GAN (Zhang et al., 2018). We train on a Google TPU v3 Pod, with the number of cores proportional to the resolution: 128 for $1 2 8 \times 1 2 8$ , 256 for $2 5 6 \times 2 5 6$ , and 512 for $5 1 2 \times 5 1 2$ . Training takes between 24 and 48 hours for most models. We increase $\epsilon$ from the default $1 0 ^ { - 8 }$ to $1 0 ^ { - 4 }$ in BatchNorm and Spectral Norm to mollify low-precision numerical issues. We preprocess data by cropping along the long edge and rescaling to a given resolution with area resampling.
+
+# C.1 BATCHNORM STATISTICS AND SAMPLING
+
+The default behavior with batch normalized classifier networks is to use a running average of the activation moments at test time. Previous works (Radford et al., 2016) have instead used batch statistics when sampling images. While this is not technically an invalid way to sample, it means that results are dependent on the test batch size (and how many devices it is split across), and further complicates reproducibility.
+
+We find that this detail is extremely important, with changes in test batch size producing drastic changes in performance. This is further exacerbated when one uses exponential moving averages of G’s weights for sampling, as the BatchNorm running averages are computed with non-averaged weights and are poor estimates of the activation statistics for the averaged weights.
+
+To counteract both these issues, we employ “standing statistics,” where we compute activation statistics at sampling time by running the G through multiple forward passes (typically 100) each with different batches of random noise, and storing means and variances aggregated across all forward passes. Analogous to using running statistics, this results in G’s outputs becoming invariant to batch size and the number of devices, even when producing a single sample.
+
+# C.2 CIFAR-10
+
+We run our networks on CIFAR-10 (Krizhevsky & Hinton, 2009) using the settings from Table 1, row 8, and achieve an IS of 9.22 and an FID of 14.73 without truncation.
+
+# C.3 INCEPTION SCORES OF IMAGENET IMAGES
+
+We compute the IS for both the training and validation sets of ImageNet. At $1 2 8 \times 1 2 8$ the training data has an IS of 233, and the validation data has an IS of 166. At $2 5 6 \times 2 5 6$ the training data has an IS of 377, and the validation data has an IS of 234. At $5 1 2 \times 5 1 2$ the training data has an IS of 348, and the validation data has an IS of 241. The discrepancy between training and validation scores is due to the Inception classifier having been trained on the training data, resulting in high-confidence outputs that are preferred by the Inception Score.
+
+# APPENDIX D ADDITIONAL PLOTS
+
+![](images/e847b965cc77291bb4c9d55739b9a1e4bec960072e20fe36d9724decf7ebbb78.jpg)  
+Figure 17: IS vs. FID at $1 2 8 \times 1 2 8$ . Scores are averaged across three random seeds.
+
+![](images/c19f550905df85c7c84aea1c6a3efc64b91cdf54ea8cc0056b0e6b39cffb6eb7.jpg)  
+Figure 18: IS vs. FID at 256 and 512 pixels. Scores are averaged across three random seeds for 256.
+
+![](images/0cac1722d5f510dbb25400f9da8a93e2d20836d44bb49e73387451cefb2e42f4.jpg)  
+Figure 19: JFT-300M IS vs. FID at $2 5 6 \times 2 5 6$ . We show truncation values from $\sigma = 0$ to $\sigma = 2$ (top) and from $\sigma = 0 . 5$ to $\sigma = 1 . 5$ (bottom). Each curve corresponds to a row in Table 3. The curve labeled with baseline corresponds to the first row (with orthogonal regularization and other techniques disabled), while the rest correspond to rows 2-4 – the same architecture at different capacities $( C h )$ .
+
+# APPENDIX E CHOOSING LATENT SPACES
+
+While most previous work has employed $\mathcal { N } ( 0 , I )$ or $\mathcal { U } [ - 1 , 1 ]$ as the prior for $z$ (the noise input to G), we are free to choose any latent distribution from which we can sample. We explore the choice of latents by considering an array of possible designs, described below. For each latent, we provide the intuition behind its design and briefly describe how it performs when used as a drop-in replacement for $z \sim \mathcal { N } ( 0 , I )$ in an SA-GAN baseline. As the Truncation Trick proved more beneficial than switching to any of these latents, we do not perform a full ablation study, and employ $z \sim \mathcal { N } ( 0 , I )$ for our main results to take full advantage of truncation. The two latents which we find to work best without truncation are Bernoulli $\{ 0 , 1 \}$ and Censored Normal max $( \mathcal { N } ( 0 , I ) , 0 )$ , both of which improve speed of training and lightly improve final performance, but are less amenable to truncation.
+
+We also ablate the choice of latent space dimensonality (which by default is $z \in \mathbb { R } ^ { 1 2 8 }$ ), finding that we are able to successfully train with latent dimensions as low as $z \in \mathbb { R } ^ { 8 }$ , and that with $z \in \mathbb { R } ^ { \breve { 3 } 2 }$ we see a minimal drop in performance. While this is substantially smaller than many previous works, direct comparison to single-class networks (such as those in Karras et al. (2018), which employ a $z \in \mathbb { R } ^ { 5 1 \frac { \mathbf { s } } { 2 } }$ latent space on a highly constrained dataset with 30,000 images) is improper, as our networks have additional class information provided as input.
+
+# LATENTS
+
+• $\mathcal { N } ( 0 , I )$ . A standard choice of the latent space which we use in the main experiments.   
+• $\mathcal { U } [ - 1 , 1 ]$ . Another standard choice; we find that it performs similarly to $\mathcal { N } ( 0 , I )$ .   
+• Bernoulli $\{ 0 , 1 \}$ . A discrete latent might reflect our prior that underlying factors of variation in natural images are not continuous, but discrete (one feature is present, another is not). This latent outperforms $\mathcal { N } ( 0 , I )$ (in terms of IS) by $8 \%$ and requires $60 \%$ fewer iterations.   
+• max $( \mathcal { N } ( 0 , I ) , 0 )$ , also called Censored Normal. This latent is designed to introduce sparsity in the latent space (reflecting our prior that certain latent features are sometimes present and sometimes not), but also allow those latents to vary continuously, expressing different degrees of intensity for latents which are active. This latent outperforms $\mathcal { N } ( 0 , I )$ (in terms of IS) by $1 5 \mathrm { - } 2 0 \%$ and tends to require fewer iterations.   
+• Bernoulli $\{ - 1 , 1 \}$ . This latent is designed to be discrete, but not sparse (as the network can learn to activate in response to negative inputs). This latent performs near-identically to $\mathcal { N } ( 0 , I )$ .   
+• Independent Categorical in $\{ - 1 , 0 , 1 \}$ , with equal probability. This distribution is chosen to be discrete and have sparsity, but also to allow latents to take on both positive and negative values. This latent performs near-identically to $\mathcal { N } ( 0 , I )$ .   
+• $\mathcal { N } ( 0 , I )$ multiplied by Bernoulli $\{ 0 , 1 \}$ . This distribution is chosen to have continuous latent factors which are also sparse (with a peak at zero), similar to Censored Normal but not constrained to be positive. This latent performs near-identically to $\mathcal { N } ( 0 , I )$ . Concatenating $\mathcal { N } ( 0 , I )$ and Bernoulli $\{ 0 , 1 \}$ , each taking half of the latent dimensions. This is inspired by Chen et al. (2016), and is chosen to allow some factors of variation to be discrete, while others are continuous. This latent outperforms $\mathcal { N } ( 0 , I )$ by around $5 \%$ .   
+• Variance annealing: we sample from $\mathcal { N } ( 0 , \sigma I )$ , where $\sigma$ is allowed to vary over training. We compared a variety of piecewise schedules and found that starting with $\sigma = 2$ and annealing towards $\sigma = 1$ over the course of training mildly improved performance. The space of possible variance schedules is large, and we did not explore it in depth – we suspect that a more principled or better-tuned schedule could more strongly impact performance.   
+• Per-sample variable variance: $\mathcal { N } ( 0 , \sigma _ { i } I )$ , where $\sigma _ { i } \sim \mathcal { U } [ \sigma _ { l } , \sigma _ { h } ]$ independently for each sample $i$ in a batch, and $\left( \sigma _ { l } , \sigma _ { h } \right)$ are hyperparameters. This distribution was chosen to try and improve amenability to the Truncation Trick by feeding the network noise samples with non-constant variance. This did not appear to affect performance, but we did not explore it in depth. One might also consider scheduling $( \sigma _ { l } , \sigma _ { h } )$ , similar to variance annealing.
+
+![](images/770e6212c1b743ea9c528e3a09ef7eb70e5f0c466d78e678c36cfc62173f0bdb.jpg)  
+APPENDIX F MONITORED TRAINING STATISTICS   
+Figure 20: Training statistics for a typical model without special modifications. Collapse occurs after 200000 iterations.
+
+![](images/9578474d9f89654837f07e6854209c3ddf738b23f433d0d8477bd34296e295c7.jpg)  
+Figure 21: G training statistics with $\sigma _ { 0 }$ in $\pmb { \mathsf { G } }$ regularized towards 1. Collapse occurs after 125000 iterations.
+
+![](images/3d644dbae274a9f3ad419efd40a9555fb5b2cf71c06eddfc4c316b889ae0671d.jpg)  
+Figure 22: D training statistics with $\sigma _ { 0 }$ in $\pmb { \mathsf { G } }$ regularized towards 1. Collapse occurs after 125000 iterations.
+
+![](images/36253d8d51fbb806a4853e595b2f22389ae8535108892ba620e10634620ab0b0.jpg)  
+Figure 23: G training statistics with an R1 Gradient Penalty of strength 10 on D. This model does not collapse, but only reaches a maximum IS of 55.
+
+![](images/60d612c06ae08229ae660289f4651372aef42838ffc8ab9255206f28f2055153.jpg)  
+Figure 24: D training statistics with an R1 Gradient Penalty of strength 10 on D. This model does not collapse, but only reaches a maximum IS of 55.
+
+![](images/615febba148a0c246cc6ea9e919cffa51f498a40640d5e66810733da83cbb834.jpg)  
+Figure 25: G training statistics with Dropout (keep probability 0.8) applied to the last feature layer of D. This model does not collapse, but only reaches a maximum IS of 70.
+
+![](images/bf988cd53f4afcab0ac969176d319cb7fc14b20a3072a9f661693d69fc752459.jpg)  
+Figure 26: D training statistics with Dropout (keep probability 0.8) applied to the last feature layer of D. This model does not collapse, but only reaches a maximum IS of 70.
+
+![](images/566619c4cc62f5871f213c60d31d438c02ad5d1295627eaace07742815f47f8d.jpg)  
+Figure 27: Additional training statistics for a typical model without special modifications. Collapse occurs after 200000 iterations.
+
+![](images/88d0b0ac3d6f8fd1353070ec4894e73581f5bcafb6b77ec4e5c1863fddda2c4b.jpg)  
+Figure 28: Additional training statistics with an R1 Gradient Penalty of strength 10 on D. This model does not collapse, but only reaches a maximum IS of 55.
+
+# APPENDIX G ADDITIONAL DISCUSSION: STABILITY AND COLLAPSE
+
+In this section, we present and discuss additional investigations into the stability of our models, expanding upon the discussion in Section 4.
+
+# G.1 INTERVENING BEFORE COLLAPSE
+
+The symptoms of collapse are sharp and sudden, with sample quality dropping from its peak to its lowest value over the course of a few hundred iterations. We can detect this collapse when the singular values in G explode, but while the (unnormalized) singular values grow throughout training, there is no consistent threshold at which collapse occurs. This raises the question of whether it is possible to prevent or delay collapse by taking a model checkpoint several thousand iterations before collapse, and continuing training with some hyperparameters modified (e.g., the learning rate).
+
+We conducted a range of intervention experiments wherein we took checkpoints of a collapsed model ten or twenty thousand iterations before collapse, changed some aspect of the training setup, then observed whether collapse occurred, when it occurred relative to the original collapse, and the final performance attained at collapse.
+
+We found that increasing the learning rates (relative to their initial values) in either G or D, or both $\pmb { \mathsf { G } }$ and D, led to immediate collapse. This occurred even when doubling the learning rates from $2 \cdot 1 0 ^ { - 4 }$ in D and $5 \cdot 1 0 ^ { - 5 } $ in $\pmb { \mathsf { G } }$ , to $4 \cdot 1 0 ^ { - 4 }$ in D and $1 \cdot 1 0 ^ { - 4 }$ in G, a setting which is not normally unstable when used as the initial learning rates. We also tried changing the momentum terms (Adam’s $\beta _ { 1 }$ and $\beta _ { 2 }$ ), or resetting the momentum vectors to zero, but this tended to either make no difference or, when increasing the momentum, cause immediate collapse.
+
+We found that decreasing the learning rate in G, but keeping the learning rate in D unchanged could delay collapse (in some cases by over one hundred thousand iterations), but also crippled training— once the learning rate in $\pmb { \mathsf { G } }$ was decayed, performance either stayed constant or slowly decayed. Conversely, reducing the learning rate in D while keeping G’s learning rate led to immediate collapse. We hypothesize that this is because of the need for D to remain optimal throughout training—if its learning rate is reduced, it can no longer “keep up” with G, and training collapses. With this in mind, we also tried increasing the number of D steps per $\pmb { \mathsf { G } }$ step, but this either had no effect, or delayed collapse at the cost of crippling training (similar to decaying G’s learning rate).
+
+To further illuminate these dynamics, we construct two additional intervention experiments, one where we freeze G before collapse (by ceasing all parameter updates) and observe whether D remains stable, and the reverse, where we freeze D before collapse and observe whether G remains stable. We find that when G is frozen, D remains stable, and slowly reduces both components of its loss towards zero. However, when D is frozen, G immediately and dramatically collapses, maxing out D’s loss to values upwards of 300, compared to the normal range of 0 to 3.
+
+This leads to two conclusions: first, as has been noted in previous works (Miyato et al., 2018; Gulrajani et al., 2017; Zhang et al., 2018), D must remain optimal with respect to G both for stability and to provide useful gradient information. The consequence of G being allowed to win the game is a complete breakdown of the training process, regardless of G’s conditioning or optimization settings. Second, favoring D over G (either by training it with a larger learning rate, or for more steps) is insufficient to ensure stability even if D is well-conditioned. This suggests either that in practice, an optimal D is necessary but insufficient for training stability, or that some aspect of the system results in D not being trained towards optimality. With the latter possibility in mind, we take a closer look at the noise in D’s spectra in the following section.
+
+# G.2 SPIKES IN THE DISCRIMINATOR’S SPECTRA
+
+![](images/91765d8ef82963256049d6b672c0086e916f6f0b6f49f8dfdf37338189f4c5b0.jpg)  
+Figure 29: A closeup of D’s spectra at a noise spike.
+
+If some element of D’s training process results in undesirable dynamics, it follows that the behavior of D’s spectra may hold clues as to what that element is. The top three singular values of D differ from G’s in that they have a large noise component, tend to grow throughout training but only show a small response to collapse, and the ratio of the first two singular values tends to be centered around one, suggesting that the spectra of D have a slow decay. When viewed up close (Figure 29), the noise spikes resemble an impulse response: at each spike, the spectra jump upwards, then slowly decrease, with some oscillation.
+
+One possible explanation is that this behavior is a consequence of D memorizing the training data, as suggested by experiments in Section 4.2. As it approaches perfect memorization, it receives less and less signal from real data, as both the original GAN loss and the hinge loss provide zero gradients when D outputs a confident and correct prediction for a given example. If the gradient signal from real data attenuates to zero, this can result in D eventually becoming biased due to exclusively received gradients that encourage its outputs to be negative. If this bias passes a certain threshold, D will eventually misclassify a large number of real examples and receive a large gradient encouraging positive outputs, resulting in the observed impulse responses.
+
+This argument suggests several fixes. First, one might consider an unbounded loss (such as the Wasserstein loss (Arjovsky et al., 2017)) which would not suffer this gradient attentuation. We found that even with gradient penalties and brief re-tuning of optimizer hyperparameters, our models did not stably train for more than a few thousand iterations with this loss. We instead explored changing the margin of the hinge loss as a partial compromise: for a given model and minibatch of data, increasing the margin will result in more examples falling within the margin, and thus contributing to the loss.3. Training with a smaller margin (by a factor of 2) measurably reduces performance, but training with a larger margin (by up to a factor of 3) does not prevent collapse or reduce the noise in D’s spectra. Increasing the margin beyond 3 results in unstable training similar to using the Wasserstein loss. Finally, the memorization argument might suggest that using a smaller D or using dropout in D would improve training by reducing its capacity to memorize, but in practice this degrades training.
+
+# APPENDIX H NEGATIVE RESULTS
+
+We explored a range of novel and existing techniques which ended up degrading or otherwise not affecting performance in our setting. We report them here; our evaluations for this section are not as thorough as those for the main architectural choices.
+
+Our intention in reporting these results is to save time for future work, and to give a more complete picture of our attempts to improve performance or stability. We note, however, that these results must be understood to be specific to the particular setup we used. A pitfall of reporting negative results is that one might report that a particular technique doesn’t work, when the reality is that this technique did not have the desired effect when applied in a particular way to a particular problem. Drawing overly general conclusions might close off potentially fruitful avenues of research.
+
+• We found that doubling the depth (by inserting an additional Residual block after every upor down-sampling block) hampered performance.   
+• We experimented with sharing class embeddings between both G and D (as opposed to just within $\pmb { \mathsf { G } }$ ). This is accomplished by replacing D’s class embedding with a projection from G’s embeddings, as is done in G’s BatchNorm layers. In our initial experiments this seemed to help and accelerate training, but we found this trick scaled poorly and was sensitive to optimization hyperparameters, particularly the choice of number of D steps per G step.   
+• We tried replacing BatchNorm in G with WeightNorm (Salimans & Kingma, 2016), but this crippled training. We also tried removing BatchNorm and only having Spectral Normalization, but this also crippled training.   
+• We tried adding BatchNorm to D (both class-conditional and unconditional) in addition to   
+Spectral Normalization, but this crippled training.   
+• We tried varying the choice of location of the attention block in G and D (and inserting multiple attention blocks at different resolutions) but found that at $1 2 8 \times 1 2 8$ there was no noticeable benefit to doing so, and compute and memory costs increased substantially. We found a benefit to moving the attention block up one stage when moving to $2 5 6 \times 2 5 6$ , which is in line with our expectations given the increased resolution.   
+• We tried using filter sizes of 5 or 7 instead of 3 in either $\pmb { \mathsf { G } }$ or $\mathbf { D }$ or both. We found that having a filter size of 5 in G only provided a small improvement over the baseline but came at an unjustifiable compute cost. All other settings degraded performance.   
+• We tried varying the dilation for convolutional filters in both G and D at $1 2 8 \times 1 2 8$ , but found that even a small amount of dilation in either network degraded performance.   
+• We tried bilinear upsampling in $\pmb { \mathsf { G } }$ in place of nearest-neighbors upsampling, but this degraded performance.   
+• In some of our models, we observed class-conditional mode collapse, where the model would only output one or two samples for a subset of classes but was still able to generate samples for all other classes. We noticed that the collapsed classes had embedings which had become very large relative to the other embeddings, and attempted to ameliorate this issue by applying weight decay to the shared embedding only. We found that small amounts of weight decay $( 1 0 ^ { - 6 } )$ instead degraded performance, and that only even smaller values $( 1 0 ^ { - 8 } )$ did not degrade performance, but these values were also too small to prevent the class vectors from exploding. Higher-resolution models appear to be more resilient to this problem, and none of our final models appear to suffer from this type of collapse.   
+• We experimented with using MLPs instead of linear projections from G’s class embeddings to its BatchNorm gains and biases, but did not find any benefit to doing so. We also experimented with Spectrally Normalizing these MLPs, and with providing these (and the linear projections) with a bias at their output, but did not notice any benefit.   
+• We tried gradient norm clipping (both the global variant typically used in recurrent networks, and a local version where the clipping value is determined on a per-parameter basis) but found this did not alleviate instability.
+
+# APPENDIX I HYPERPARAMETERS
+
+We performed various hyperparameter sweeps in this work:
+
+• We swept the Cartesian product of the learning rates for each network through $[ 1 0 ^ { - 5 }$ , $5 \cdot 1 0 ^ { - 5 }$ , $1 0 ^ { - 4 }$ , $2 \cdot 1 0 ^ { - 4 }$ , $4 \cdot 1 0 ^ { - 4 }$ , $8 \cdot 1 0 ^ { - 4 } $ , $1 0 ^ { = 3 } ]$ , and initially found that the SA-GAN settings (G’s learning rate $1 0 ^ { - 4 }$ , D’s learning rate $4 \cdot 1 0 ^ { - 4 } \ $ ) were optimal at lower batch sizes; we did not repeat this sweep at higher batch sizes but did try halving and doubling the learning rate, arriving at the halved settings used for our experiments. We swept the R1 gradient penalty strength through $[ 1 0 ^ { - 3 }$ , $1 0 ^ { - 2 }$ , $1 0 ^ { - 1 }$ , 0.5, 1, 2, 3, 5, 10]. We find that the strength of the penalty correlates negatively with performance, but that settings above 0.5 impart training stability.   
+• We swept the keep probabilities for DropOut in the final layer of D through [0.5, 0.6, 0.7, 0.8, 0.9, 0.95]. We find that DropOut has a similar stabilizing effect to R1 but also degrades performance.   
+• We swept D’s Adam $\beta _ { 1 }$ parameter through [0.1, 0.2, 0.3, 0.4, 0.5] and found it to have a light regularization effect similar to DropOut, but not to significantly improve results. Higher $\beta _ { 1 }$ terms in either network crippled training.   
+• We swept the strength of the modified Orthogonal Regularization penalty in G through $[ 1 0 ^ { - 5 }$ , $5 \cdot 1 0 ^ { - 5 }$ , $1 0 ^ { - 4 }$ , $5 \cdot 1 0 ^ { - 4 } $ , $1 0 ^ { - 3 }$ , $1 0 ^ { - 2 } ]$ , and selected $1 0 ^ { - 4 }$ .

parse/train/CLCVcl1rSPP/CLCVcl1rSPP.md

@@ -0,0 +1,320 @@
+# RL for Latent MDPs: Regret Guarantees and a Lower Bound
+
+Jeongyeol Kwon The University of Texas at Austin kwonchungli@utexas.edu
+
+Yonathan Efroni Microsoft Research, NYC jonathan.efroni@gmail.com
+
+Constantine Caramanis The University of Texas at Austin constantine@utexas.edu
+
+Shie Mannor Technion, NVIDIA shie@ee.technion.ac.il, smannor@nvidia.com
+
+# Abstract
+
+In this work, we consider the regret minimization problem for reinforcement learning in latent Markov Decision Processes (LMDP). In an LMDP, an MDP is randomly drawn from a set of $M$ possible MDPs at the beginning of the interaction, but the identity of the chosen MDP is not revealed to the agent. We first show that a general instance of LMDPs requires at least $\Omega ( ( S A ) ^ { M } )$ episodes to even approximate the optimal policy. Then, we consider sufficient assumptions under which learning good policies requires polynomial number of episodes. We show that the key link is a notion of separation between the MDP system dynamics. With sufficient separation, we provide an efficient algorithm with local guarantee, i.e., providing a sublinear regret guarantee when we are given a good initialization. Finally, if we are given standard statistical sufficiency assumptions common in the Predictive State Representation (PSR) literature (e.g., [6]) and a reachability assumption, we show that the need for initialization can be removed.
+
+# 1 Introduction
+
+Partially observable Markov decision processes (POMDPs) [42] give a general framework to describe partially observable sequential decision problems. In POMDPs, the underlying dynamics satisfy the Markovian property, but the observations give only partial information on the identity of the underlying states. With the generality of this framework comes a high computational and statistical price to pay: POMDPs are hard, primarily because optimal policies depend on the entire history of the process. But for many important problems, this full generality can be overkill, and in particular, does not have a way to leverage special structure. We are interested in settings where the hidden or latent (unobserved) variables have slow dynamics or are even static in each episode. This model is important for diverse applications, from serving a user in a dynamic web application [18], to medical decision making [45], to transfer learning in different RL tasks [8]. Yet, as we explain below, even this area remains little understood, and challenges abound.
+
+Thus, in this work, we consider reinforcement learning (RL) for a special type of POMDP which we call a latent Markov decision process (LMDP). LMDPs consist of some (perhaps large) number $M$ of MDPs with joint state space $s$ and actions $\mathcal { A }$ . In episodic LMDPs with finite time-horizon $H$ , the static latent (hidden) variable that selects one of $M$ MDPs is randomly chosen at the beginning of each episode, yet is not revealed to the agent. The agent then interacts with the chosen MDP throughout the episode (see Definition 1 for the formal description).
+
+Related Work. The LMDP framework has previously been introduced under many different names, e.g., hidden-model MDP [11], Multitask RL [8], Contextual MDP [18], Multi-modal Markov decision process [45] and Concurrent MDP [9].
+
+Learning in LMDPs is a challenging problem due to the unobservability of latent contexts. For instance, the exact planning problem is P-SPACE hard [45], inheriting the hardness of planning from the general POMDP framework. Nevertheless, the lack of dynamics of the latent variables, offers some hope. As an example, if the number of contexts $M$ is bounded, then the planning problem can be at least approximately solved (e.g., by point-based value iteration (PBVI) [39], or mixed integer programming (MIP) [45]).
+
+The most closely related work studying LMDPs is in the context of multitask RL [47, 8, 34, 18]. In this line of work, a common approach is to cluster trajectories according to different contexts, an approach that guided us in designing the algorithms in Section 3.4. However, previous work requires very long time-horizon $H \gg S A$ in order to guarantee that every state-action pair can be visited multiple times in a single episode. In contrast, we consider a significantly shorter time-horizon that scales poly-logarithmic with the number of states, i.e., $H = p o l y \bar { \log ( M S \dot { A } ) }$ . This short time-horizon results in a significant difference in learning strategy even when we get a feedback on the true context at the end of episode. We refer the readers to Appendix A for additional discussion on related work.
+
+Main Results. To the best of our knowledge, none of the previous literature has obtained sample complexity guarantees or studied regret bounds in the LMDP setting. This paper addresses precisely this problem. We ask the following:
+
+Is there a sample efficient RL algorithm for LMDPs, with sublinear regret?
+
+The answer turns out to be not so simple. Our results comprise a first impossibility result, followed by positive algorithmic results under additional assumptions. Specifically:
+
+• First, we find that for a general LMDP, polynomial sample complexity cannot be attained without further assumptions. That is, to find an approximately optimal policy we need at least $\Omega \left( ( S A ) ^ { M } \right)$ samples, i.e., at least exponential in the number of contexts $M$ (Section 3.1). This lower bound even applies to instances with deterministic MDPs.   
+• We find that there are several natural assumptions under which optimal policies can be learned with polynomial sample complexity. Similarly to mixture problems without dynamics, the key link is a notion of separation between the MDPs. With sufficient separation, we show that there is a planning-oracle efficient RL algorithm with polynomial sample complexity. A critical development is adapting the principle of optimism as in UCB, but to the partially observed setting where value-iteration cannot be directly applied, and thus neither can the UCRL algorithm for MDPs.   
+• Finally, under additional statistical sufficiency assumptions that are common in the Predictive State Representation (PSR) literature (e.g., [6]) and a reachability assumption, we show that the need for initialization can be entirely removed.   
+• Finally, we perform an empirical evaluation of the suggested algorithms on toy problems (Section 4), while focusing on the importance of the made assumptions.
+
+# 2 Preliminaries
+
+# 2.1 Problem Setup: Latent MDPs
+
+We start with the definition of episodic reinforcement learning in latent Markov decision process:
+
+Definition 1 (Latent Markov Decision Process (LMDP)) Consider a set of MDPs $\mathcal { M }$ with joint state space $s$ and joint action space $\mathcal { A }$ in a finite time horizon $H$ . Let $M = | { \mathcal { M } } |$ , $S = | S |$ and $A = | { \mathcal { A } } |$ . Each MDP $\mathcal { M } _ { m } \in \mathcal { M }$ is a tuple $( \mathcal { S } , \mathcal { A } , T _ { m } , R _ { m } , \nu _ { m } )$ where $T _ { m } : S \times A \times S  [ 0 , 1 ]$ a transition probability maps a state-action pair and a next state to a probability, ${ R _ { m } } : S \times A \times \{ 0 , 1 \} \to [ 0 , 1 ]$ a probability measure for rewards that maps a state-action pair and a binary reward to a probability, and $\nu _ { m }$ is an initial state distribution. Let $w _ { 1 } , . . . , w _ { M }$ be the mixing weights of LMDPs such that at the start of every episode, one MDP $\mathcal { M } _ { m } \in \mathcal { M }$ is randomly chosen with probability $w _ { m }$ .
+
+We assume the mixing weights are uniform and known a priori, i.e., $w _ { 1 } = . . . = w _ { M } = 1 / M$ . This is only for the ease of presentation, and does not affect any algorithmic idea or main results in this paper. The goal of the problem is to Π that maximizes the expected return: $\pi$ n a pol ,where ssis $\begin{array} { r } { V _ { { \mathcal { M } } } ^ { * } : = \operatorname* { m a x } _ { \pi \in \Pi } \sum _ { m = 1 } ^ { M } w _ { m } \mathbb { E } _ { m } ^ { \pi } \left[ \sum _ { t = 1 } ^ { H } r _ { t } \right] } \end{array}$ $\mathbb { E } _ { m } ^ { \pi } [ \cdot ]$ expectation taken over the $m ^ { t h }$ MDP with a policy $\pi$ . If not specified otherwise, we find the best policy in a set of history-dependent policies $\bar { \pi } : ( \bar { S } , \mathcal { A } , \{ 0 , 1 \} ) ^ { * } \times \mathcal { S }  \Delta ( A )$ that map an entire history to a probability distribution over actions.
+
+We define the notion of regret relative to a (possibly approximate) planning oracle. Thus, suppose we have a planning-oracle with the following approximation guarantee: $V _ { \mathcal { M } } ^ { \pi } \geq \rho _ { 1 } V _ { \mathcal { M } } ^ { * } - \rho _ { 2 }$ , where $\pi$ is a returned policy when $\mathcal { M }$ is given to the planning-oracle, and $\rho _ { 1 } , \rho _ { 2 }$ are multiplicative and additive approximation constants respectively. We then define the regret as the comparison to the best approximation guarantee that the planning-oracle can achieve:
+
+$$
+R e g r e t ( K ) = \sum _ { k = 1 } ^ { K } ( \rho _ { 1 } V _ { \mathcal { M } } ^ { * } - \rho _ { 2 } ) - V _ { \mathcal { M } } ^ { \pi _ { k } } ,
+$$
+
+where $\pi _ { k }$ is a policy executed in the $k ^ { t h }$ episode. For example, we can use point-based value-iteration (PBVI) [39] as a planning-oracle:
+
+Example 1 PBVI [39] with discretization level $\epsilon _ { d } > 0$ in the belief space (over $\mathbb { R } ^ { M }$ ) returns an $\epsilon _ { d } H ^ { 2 }$ additive approximate policy. That is, equation (1) holds with $\rho _ { 1 } = 1$ and $\rho _ { 2 } = \epsilon _ { d } H ^ { 2 }$ .
+
+# 2.2 Predictive State Representation (PSR)
+
+A partially observable dynamical system can be viewed as a model that generates a sequence of observations from observation space $\mathcal { O }$ with (controlled) actions from action space $\mathcal { A }$ . A predictive state representation (PSR) is a compact description of a dynamical system with a set of observable experiments, or tests [41]. Specifically, a test of length $t$ is a sequence of action-observation pairs given as $\tau = { a _ { 1 } ^ { \tau } o _ { 1 } ^ { \tau } o _ { 2 } ^ { \tau } . . . a _ { t } ^ { \tau } o _ { t } ^ { \tau } }$ . A history $h = a _ { 1 } ^ { h } o _ { 1 } ^ { h } a _ { 2 } ^ { \tilde { h _ { } } } o _ { 2 } ^ { h } . . . a _ { t } ^ { h } o _ { t } ^ { h }$ is a sequence of action-observation pairs that has been generated prior to a given time. A prediction $\mathbb { P } ( \tau | h ) { \overset { - } { = } } \mathbb { P } ( o _ { 1 : t } ^ { \tau } | h | | d o a _ { 1 : t } ^ { \tau } )$ denotes the probability of seeing the test sequence from a given history, given that we intervene to take actions $a _ { 1 } ^ { \tau } a _ { 2 } ^ { \tau } . . . a _ { t } ^ { \tau }$ . In latent MDPs, the observation space can be considered as a pair of next-states and rewards, i.e., ${ \mathcal { O } } = { \mathcal { S } } \times \{ 0 , 1 \}$ and $o _ { t } = \left( s _ { t + 1 } , r _ { t } \right)$ .
+
+As we work with a special class of POMDPs, we customize the formulation for LMDPs. The set of histories consists of a subset of histories that end with different states, i.e., $\textstyle { \mathcal { H } } = \bigcup _ { s } { \mathcal { H } } _ { s }$ , where each element $h \in \mathcal { H } _ { s }$ is a short sequence of state-action-rewards of length $l$ ending with state $s$ :
+
+$$
+h = s _ { 1 } ^ { h } a _ { 1 } ^ { h } r _ { 1 } ^ { h } s _ { 2 } ^ { h } . . . s _ { l - 1 } ^ { h } a _ { l - 1 } ^ { h } r _ { l - 1 } ^ { h } s = ( s , a , r ) _ { 1 : l - 1 } ^ { h } s .
+$$
+
+We define $\mathbb { P } _ { m } ^ { \pi } ( \mathcal { H } _ { s } )$ a vector of probabilities where each coordinate is a probability of sampling each history in $\mathcal { H } _ { s }$ in the $m ^ { t h }$ MDP with a policy $\pi$ . Likewise, each element in tests $\tau \in \mathcal { T }$ is a short sequence of action-reward-next states of length at most $l$ :
+
+$$
+\tau = a _ { 1 } ^ { \tau } r _ { 1 } ^ { \tau } s _ { 2 } ^ { \tau } . . . a _ { l } ^ { \tau } r _ { l } ^ { \tau } s _ { l + 1 } ^ { \tau } = ( a , r , s ^ { \prime } ) _ { 1 : l } ^ { \tau } .
+$$
+
+We denote $\mathbb { P } _ { m } ( \mathcal { T } | s )$ as a vector of probability where each coordinate is a success probability of each test in the $m ^ { t h }$ MDP starting from a state $s$ . That is,
+
+$$
+\mathbb { P } _ { m } ( \mathcal { T } | s ) _ { i } = \mathbb { P } _ { m } \big ( r _ { 1 } ^ { \tau _ { i } } s _ { 2 } ^ { \tau _ { i } } . . . r _ { l } ^ { \tau _ { i } } s _ { l + 1 } ^ { \tau _ { i } } | s | \big | d o a _ { 1 } ^ { \tau _ { i } } . . . a _ { l } ^ { \tau _ { i } } \big ) .
+$$
+
+# 2.2.1 Spectral Learning of PSRs in LMDPs
+
+In spectral learning, we build a set of observable matrices that contains the (joint) probabilities of histories and tests, and then we can extract parameters from these matrices by performing singular value decomposition (SVD) and regressions [7]. In order to apply spectral learning techniques, we require the following technical conditions on statistical sufficiency of tests:
+
+Condition 1 (Sufficient Tests) For all $ { \mathcal { S } } _ { s } \in  { \mathcal { S } } _ { }$ , for the test set $\tau$ , let $\begin{array} { r l } { L _ { s } } & { { } = } \end{array}$ $[ \mathbb { P } _ { 1 } ( \pmb { \mathscr { T } } | s ) | \mathbb { P } _ { 2 } ( \pmb { \mathscr { T } } | s ) | . . . | \mathbb { P } _ { M } ( \pmb { \mathscr { T } } | s ) ]$ . Then $\sigma _ { M } ( L _ { s } ) \geq \sigma _ { \tau }$ for all $s \in S$ with some $\sigma _ { \tau } > 0$ .
+
+Here, $\sigma _ { M } ( \cdot )$ is the minimum $( M ^ { t h } )$ singular value of a matrix. Another technical condition for spectral learning method is a rank non-degeneracy condition for sufficient histories:
+
+Condition 2 (Sufficient Histories) For all $s \in \mathcal { S }$ , for the history set $\mathcal { H } _ { s }$ ending with a state $s$ , let $H _ { s } \ = \ [ \mathbb { P } _ { 1 } ^ { \pi } ( \mathcal { H } _ { s } ) | \mathbb { P } _ { 2 } ^ { \pi } ( \mathcal { H } _ { s } ) | . . . | \mathbb { P } _ { M } ^ { \pi } ( \mathcal { H } _ { s } ) ] ^ { \intercal }$ with a sampling policy $\pi$ . Then $\sigma _ { M } ( L _ { s } H _ { s } ) \geq $ $\mathbb { P } ^ { \pi } ( e n d s t a t e = s ) \cdot \sigma _ { h }$ with some $\sigma _ { h } > 0$ .
+
+Here $\mathbb { P } ^ { \pi }$ (end state $= s$ ) is a probability of sampling a history ending with $s$ . Along with the rank condition for tests, pairs of histories and tests can be thought as many short snap-shots of long trajectories obtained by external experts or some exploration policy (e.g., random policy in uniformly ergodic MDPs). Following the notations in [7], let $P _ { \tau , \mathcal { H } _ { s } } = L _ { s } H _ { s }$ . Conditions 1 and 2 ensure $\bar { \sigma _ { M } } ( P _ { T , \mathcal { H } _ { s } } ) > 0$ . Under these conditions, the goal of spectral learning algorithm is to output PSR parameters which are used to compute ${ \hat { \mathbb { P } } } ( \tau | h )$ , the estimated probability of any future observations (or tests $\tau$ ) given any sampled histories $h$ . We refer to Appendix E.1 for a detailed procedure.
+
+# 2.3 Notations
+
+We denote the underlying LMDP with true parameters as $\mathcal { M } ^ { * }$ . With slight abuse of notation, we denote the $l _ { 1 }$ distance between two probability distributions $\mathcal { D } _ { 1 }$ and $\mathcal { D } _ { 2 }$ on a random variable $X$ conditioned on event $E$ as $\begin{array} { r } { \| ( \mathbb { P } _ { X \sim \mathcal { D } _ { 1 } } - \mathbb { P } _ { X \sim \mathcal { D } _ { 2 } } ) ( X | E ) \| _ { 1 } = \sum _ { X \in \mathcal { X } } | \mathbb { P } _ { X \sim \mathcal { D } _ { 1 } } ( X | E ) - \mathbb { P } _ { X \sim \mathcal { D } _ { 2 } } ( X | E ) | } \end{array}$ , where $\mathcal { X }$ is a support of $X$ . When we do not condition on any event, we omit the conditioning on $E$ . When we measure a transition or reward probability at a state-action pair $( s , a )$ , we use $T$ or $R$ instead of $\mathbb { P }$ . We use $\mathbb { P } _ { m }$ to refer to the probability of any event measured in the $m ^ { t h }$ context (or in $m ^ { t h }$ MDP). In particular, $\mathbb { P } _ { m } ( s ^ { \prime } , r | s , \bar { a } ) = T _ { m } \bar { ( } s ^ { \prime } | s , a ) R _ { m } ( r | s , a )$ . If we use $\mathbb { P }$ without any subscript, it is a probability of an event measured outsidethe probability of an event depends on a policy f the context, i.e., , we add superscri $\begin{array} { r } { \mathbb { P } ( \cdot ) = \sum _ { m = 1 } ^ { M } w _ { m } \mathbb { P } _ { m } ( \cdot ) } \end{array}$ Ifis $\pi$ $\pi$ $\mathbb { P }$ $\mathbb { E } _ { m } [ \cdot ]$ expectation taken over the $m ^ { t h }$ context and $\pi$ is added as superscript if the expectation depends on $\pi$ . We use ˆ· to denote any estimated quantities. $a \lesssim b$ implies $a$ is less than $b$ up to some constant and logarithmic factors. $p o l y ( \cdot )$ means the order of polynomial complexity (up to logarithmic factors) in referenced parameters. We interchangeably use $o$ , an observation, to replace a pair of next-state and immediate reward $( s ^ { \prime } , r )$ to simplify the notation. We occasionally express a length $t > 0$ history $( s _ { 1 } , a _ { 1 } , r _ { 1 } , . . . , s _ { t } , a _ { t } , r _ { t } )$ compactly as $( s , a , r ) _ { 1 : t }$ .
+
+# 3 Main Results
+
+In this section, we first obtain a hardness result for the general case. We then consider sample- and computationally efficient algorithms under additional assumptions.
+
+# 3.1 Fundamental Limits of Learning General LMDPs
+
+We first study the fundamental limits of the problem. In particular, we are interested in whether we can learn the optimal policy after interacting with the LMDP for a number of episodes polynomial in the problem parameters. We prove a worst-case lower bound, exhibiting an instance of LMDP that requires at least $\Omega \left( ( S A ) ^ { M } \right)$ episodes:
+
+Theorem 3.1 (Lower Bound) There exists an LMDP such that for finding an -optimal policy $\pi _ { \epsilon }$ for which $V _ { \mathcal { M } } ^ { \pi _ { \epsilon } } \geq V _ { \mathcal { M } } ^ { * } - \epsilon$ , we need at least $\Omega \left( ( S A / M ) ^ { M } / \epsilon ^ { 2 } \right)$ episodes.
+
+The hard instance consists of fully deterministic MDPs with possibly stochastic rewards, indicating an exponential lower bound in the number of contexts even for the easiest types of LMDPs. The example is constructed such that, in the absence of knowing true contexts, all wrong action sequences of length $M$ cannot provide any information with zero reward, whereas the only correct action sequence gets a total reward of 1 under one specific context. The construction is given in Appendix B.
+
+Theorem 3.1 prevents a design of efficient algorithms with growing number of contexts. We note here that Theorem 3.1 holds even for restricted classes of policies, e.g., memoryless policies. Furthermore, our construction of hard instances does not allow to find any approximate policy with $\rho _ { 1 } = \omega ( ( S A ) ^ { - M } )$ within a polynomial number of episodes either. To the best of our knowledge, this
+
+Initialize visit counts $N _ { m } ( s , a ) , N ( m )$ and parameters $( \hat { T } _ { m } , \hat { R } _ { m } , \hat { \nu } _ { m } )$ properly
+
+1: for each $k ^ { t h }$ episode do   
+2: Get a policy $\pi _ { k }$ for $\widetilde { \mathcal { M } } _ { k }$ in Lemma 3.2   
+3: Play policy $\pi _ { k }$ and get the trajectory $\tau = ( s , a , r ) _ { 1 : H }$   
+4: Get an estimated belief over contexts $\hat { b }$ with either Algorithm 2 (when contexts are given), or   
+Algorithm 3 (when we infer contexts)   
+5: for $m = 1 , . . . , M$ and $t = 1 , . . . , H$ do   
+6: $N _ { m } ( s _ { t + 1 } | a _ { t } , s _ { t } ) \gets N _ { m } ( s _ { t + 1 } | a _ { t } , s _ { t } ) + \hat { b } ( m )$   
+7: $N _ { m } ( r _ { t } | s _ { t } , a _ { t } ) \gets N _ { m } ( r _ { t } | s _ { t } , a _ { t } ) + \hat { b } ( m )$   
+8: $N _ { m } ( s _ { 1 } ) \gets N _ { m } ( s _ { 1 } ) + \hat { b } ( m )$   
+9: Update empirical parameters $\hat { T } _ { m } , \hat { R } _ { m } , \hat { \nu } _ { m }$   
+10: end for   
+11: end for
+
+is the first lower bound of its kind for LMDPs. Next, we investigate natural assumptions which help us to develop an efficient algorithm when only polynomial number of episodes are available.
+
+# 3.2 The Critical First Step: Contexts in Hindsight
+
+Suppose the true context of the underlying MDP is revealed to the agent at the end of each episode. We do not require any assumptions on the environments in this scenario. Note that this scenario is different from fully observable settings (i.e., knowing the true context at the beginning of an episode). In the latter scenario, we would simply have $M$ -decoupled RL problems in standard MDPs. While this can be considered as a “warm-up” for the sequel, it is motivated by real-world examples. Moreover, the key technical insight here will prove important for the sequel as well.
+
+Knowing contexts in hindsight allows us to construct a confidence set for parameters:
+
+$$
+\begin{array} { r } { \mathcal { C } = \{ \mathcal { M } \ | \| ( \nu _ { m } - \hat { \nu } _ { m } ) ( s ) \| _ { 1 } \leq \sqrt { c _ { \nu } / N ( m ) } , \ \| ( T _ { m } - \hat { T } _ { m } ) ( s ^ { \prime } | s , a ) \| _ { 1 } \leq \sqrt { c _ { T } / N _ { m } ( s , a ) } , } \\ { \| ( R _ { m } - \hat { R } _ { m } ) ( r | s , a ) \| _ { 1 } \leq \sqrt { c _ { R } / N _ { m } ( s , a ) } , \quad \forall m , s , a \} , } \end{array}
+$$
+
+where $N _ { m } ( s , a )$ is the number of times each state-action pair $( s , a )$ in $m ^ { t h } ~ \mathrm { { M D P } }$ is visited, and $N ( m )$ is the number of episodes we interact with the $m ^ { t h }$ MDP. With properly set parameters $\dot { c _ { T } } = { \cal O } ( S \log ( K / \eta ) ) , c _ { R } \dot { = } { \cal O } ( \log ( K / \eta ) )$ and $c _ { \nu } = O ( S \log ( K / \eta ) )$ for the confidence intervals, $\mathcal { M } ^ { \ast } \in \mathcal { C }$ with high probability for all $K$ episodes.
+
+With the construction of confidence sets, it is then natural to try to design an optimistic RL algorithm, as in UCRL [22]. An obvious optimistic value in light of (2) is $\operatorname* { m a x } _ { \pi } { } , \mathcal { M } \in \mathcal { C }  \ : V _ { \mathcal { M } } ^ { \pi }$ . However, solving this optimization problem is more general than solving an LMDP. In fully observable settings, we could replace the complex optimization problem by adding a proper exploration bonus to obtain an optimistic value function [4].
+
+In partially observable environments, value iteration is only defined in terms of belief-states and not the observed states. For this reason, existing techniques solely based on the value-iteration cannot be directly applied for LMDPs. Yet, we find that proper analysis of the Bellman update rule over the belief state reveals that an empirical LMDP with properly adjusted hidden rewards is optimistic:
+
+Proposition 3.2 We construct an optimistic LMDP $\widetilde { \mathcal { M } }$ whose parameters are given such that:
+
+$$
+\begin{array} { r l } & { \widetilde { T } _ { m } ( s ^ { \prime } | s , a ) = \hat { T } _ { m } ( s ^ { \prime } | s , a ) , \ \widetilde { R } _ { m } ^ { o b s } ( r | s , a ) = \hat { R } _ { m } ( r | s , a ) , \ \widetilde { \nu } _ { m } ( s ) = \hat { \nu } _ { m } ( s ) , } \\ & { \widetilde { R } _ { i n i t } ^ { h i d } ( m ) = \operatorname* { m i n } \left( 1 , \sqrt { c _ { \nu } / N ( m ) } \right) \ \widetilde { R } _ { m } ^ { h i d } ( s , a ) = H \operatorname* { m i n } \left( 1 , \sqrt { 5 \left( c _ { R } + c _ { T } \right) / N _ { m } ( s , a ) } \right) , } \end{array}
+$$
+
+where $\widetilde { R } _ { i n i t } ^ { h i d } ( m )$ is an initial hidden reward given when starting an episode with a context $m$ , and $\widetilde { R } _ { m } ^ { o b s } ( \cdot | s , a )$ is a probability measure of an observable immediate reward $r$ whereas $\widetilde { R } _ { m } ^ { h i d } ( s , a )$ is $a$ hidden immediate reward (that is not visible to the agent) for a state-action pair $( s , a )$ in a context $m$ . Then for any policy $\pi$ , the expected long-term reward is optimistic, i.e., $V _ { \widehat { \mathcal { M } } } ^ { \pi } \geq V _ { \mathcal { M } ^ { \ast } } ^ { \pi }$ .
+
+Algorithm 2 Access to True Contexts
+
+Input: Receive true context $m ^ { * }$ in hindsight
+
+Output : Belief over hidden contexts:
+
+$$
+\hat { b } ( m ) = \left\{ \begin{array} { l l } { { 1 , } } & { { \mathrm { f o r } m = m ^ { * } } } \\ { { 0 , } } & { { \mathrm { f o r } m \ne m ^ { * } } } \end{array} \right.
+$$
+
+# Algorithm 3 Inference of Contexts
+
+Input: Trajectory $\tau = ( s _ { 1 } , a _ { 1 } , r _ { 1 } , . . . , s _ { H } , a _ { H } , r _ { H } )$ Output: Return an estimate of belief over contexts $\hat { b }$ :
+
+$$
+\begin{array} { l } { \hat { p } _ { m } ( \tau ) = \Pi _ { t = 1 } ^ { H } ( \alpha + ( 1 - 2 \alpha S ) \hat { \mathbb { P } } _ { m } ( s _ { t + 1 } , r _ { t } | s _ { t } , a _ { t } ) ) , } \\ { \hat { b } ( m ) = \frac { \hat { p } _ { m } ( \tau ) } { \sum _ { m = 1 } ^ { M } \hat { p } _ { m } ( \tau ) } . } \end{array}
+$$
+
+Here, hidden reward is a deterministic reward that happens for every state-action pair, but does not appear in any observation history during the episode. We note that most existing planning algorithms can incorporate the hidden-reward structure without changes to maximize the long-term observed $^ +$ hidden rewards. For instance, the PBVI algorithm [39] can be executed as it is in the planning step. Hence in each episode, we can build one optimistic model from Proposition 3.2, and call the planning-oracle to get a policy to execute for the episode. Then we simply run the policy and update model parameters in a straight-forward manner. The algorithm can be efficiently implemented as long as some efficient (approximate) planning algorithms are available.
+
+To establish Proposition 3.2, we make use of the ‘alpha vector’ representation [42] of the value function of general POMDPs. Detailed analysis is deferred to Appendix C.1. With the optimistic model constructed in Proposition 3.2, planning-oracle efficient implementation is straightforward. The resulting latent upper confidence reinforcement learning (L-UCRL) algorithm is summarized in Algorithm 1. Based on the established optimism in Proposition 3.2 and by carefully bounding the on-policy errors we arrive to the following regret guarantee of L-UCRL.
+
+Theorem 3.3 Let $N = H K$ . The regret of the Algorithm 1 is bounded by:
+
+$$
+R e g r e t ( K ) \leq \sum _ { k = 1 } ^ { K } ( V _ { \widehat { \mathcal { M } } _ { k } } ^ { \pi _ { k } } - V _ { \mathcal { M } ^ { * } } ^ { \pi _ { k } } ) \lesssim H S \sqrt { M A N } .
+$$
+
+Proof of Theorem 3.3 is given in Appendix C.4. The central result of this section, Theorem 3.3 leads to the following observation: a polynomial sample complexity is possible for the LMDP model assuming the context of the underlying MDP is supplied at the end of each episode. Next, we explore ways to relax this assumption, while keep supplying with a polynomial sample complexity guarantee.
+
+# 3.3 When we can Infer Contexts?
+
+Without explicit access to the true context at the end of an episode, it is natural to estimate the context from the sampled trajectory. One sufficient condition to infer the context is the following:
+
+Assumption 1 $\boldsymbol { \delta }$ -Strongly Separated MDPs) For all $m$ , $m _ { 1 } , m _ { 2 } \in [ M ]$ such that $m _ { 1 } \neq m _ { 2 }$ , for all $( s , a ) \in \mathcal { S } \times \mathcal { A } , l$ $l _ { 1 }$ distance between probability of observations $o = \bar { ( \boldsymbol { s } ^ { \prime } , \boldsymbol { r } ) }$ of two different $M D P s$ in $L M D P$ is at least $\delta > 0$ , i.e., $\| ( \mathbb { P } _ { m _ { 1 } } - \mathbb { P } _ { m _ { 2 } } ) ( o | s , a ) \| _ { 1 } \geq \delta$ for some constant $\delta > 0$ .
+
+In order to reliably infer the true contexts the seperatedness between MDPs alone is not sufficient, since we need to estimate the contexts from the current empirical estimates of LMDPs. In order to reliably estimate the context from empirical estimate of LMDPs, we need a well-initialized empirical transition model of the LMDP:
+
+$$
+\| ( \hat { T } _ { m } - T _ { m } ) ( s ^ { \prime } | s , a ) \| _ { 1 } , \ \| ( \hat { \nu } _ { m } - \nu _ { m } ) ( s ) \| _ { 1 } , \ \| ( \hat { R } _ { m } - R _ { m } ) ( r | s , a ) \| _ { 1 } \leq \epsilon _ { i n i t } , \qquad \forall ( s , a ) ,
+$$
+
+for some initialization error $\epsilon _ { i n i t } > 0$ . Note that while the initialization error is relatively small, it can be still not good enough to obtain a near-optimal policy (i.e., it will result in a linear regret). We can consider as if the state-action pairs are already visit at least $N _ { 0 } = c _ { T } / \epsilon _ { i n i t } ^ { 2 }$ times in each context.
+
+Once the initialization is given along with separation between MDPs, we can modify Algorithm 1 to update the empirical estimate of LMDP using the estimated belief over contexts computed in Algorithm 3. Note that when we update the model parameters, we increase the visit count of stateaction pair $( s , a )$ at $m ^ { t h }$ MDP by $\hat { b } ( m )$ . With Assumption 1, it approximately adds a count for the correctly estimated context, but even without Assumption 1, the update steps can still be applied. In fact, this is equivalent to an implementation of the so-called (online) expectation-maximization (EM) algorithm [10] for latent MDPs. Thus Algorithm 1 with Algorithm 3 essentially results in combining L-UCRL and the EM algorithm.
+
+<table><tr><td colspan="2">Learn PSR parameters up to precision o(δ)</td></tr><tr><td colspan="2">Get clusters {Tm(*|s,a), Rm(-|s,a)}(s,a)∈S× A,m∈[M] with learned PSR parameters Build each MDP model by correctly assigning contexts to estimated model parameters Return Well-initialized model {Tm, Rm}m∈[M]</td></tr></table>
+
+In terms of performance guarantees, using Algorithm 3 as a sub-routine for L-UCRL gives the same order of regret as in Theorem 3.3 as long as the true context can be almost reliably inferred:
+
+Theorem 3.4 Suppose Assumption 1 holds with $H > C \cdot \delta ^ { - 4 } \log ^ { 2 } ( 1 / \alpha ) \log ( N / \eta ) .$ for some absolute constants $C , \delta > 0$ , and a parameter $\alpha > 0$ such that $\alpha \ln ( 1 / \alpha ) \leq \delta ^ { 2 } / ( 2 0 0 S )$ . If the initialization parameters satisfy equation (3) with some initialization error $\epsilon _ { i n i t } \leq \delta ^ { 2 } / ( 2 0 0 \ln ( 1 / \alpha ) )$ , then with probability at least $1 - \eta$ , the regret of Algorithm $^ { l }$ is bounded by:
+
+$$
+R e g r e t ( K ) \lesssim H S \sqrt { M A N } .
+$$
+
+The proof of Theorem 3.4 is given in Appendix D.3. The provable guarantees are only given for wellseparated LMDPs. Nevertheless, we empirically evaluate Algorithm 1 as a function of separations and initialization (see Figure 1).
+
+An interesting consequence of Assumption 1 is that the length of episode can be logarithmic in the number of state and actions. With much longer time-horizons $H \overset { \cdot } { \geq } \Omega ( S ^ { 2 } A / \delta ^ { 2 } )$ , [8, 18] assumed similar $\delta$ -separation only for some $( s , a )$ pairs. While Assumption 1 requires a stronger assumption of $\delta$ -separation for all state-actions, the requirement on the time-horizon can be significantly weaker with large state and action spaces. For a more discussion on the separation condition, we refer the readers to Appendix D.1.
+
+# 3.4 Learning LMDPs without Initialization
+
+Finally, we discuss efficient initialization with some additional assumptions. Clustering trajectories is the cornerstone of all our technical results, as this allows us to estimate the parameters of each hidden MDP and then apply the techniques of Section 3.2. The challenge is how to cluster when we have short trajectories, and no good initialization.
+
+The key is again in Assumption 1. In Section 3.3, we use a good initialization to obtain accurate estimates of the belief states. These can then be clustered, thanks to Assumption 1, allowing us to obtain the true label in hindsight. Without initialization, we cannot accurately compute the belief state, so this avenue is blocked. Instead, our key idea is to leverage a predictive state representation (PSR) of the POMDP dynamics, and then show that Assumption 1 allows us to cluster in this space.
+
+Algorithm 4 gives our approach. We first explain the high-level idea, and subsequently detail some of the more subtle points. Suppose we have PSR parameters allowing us to estimate ${ \dot { \mathbb { P } } } ( o | h | | \mathbf { d o } a )$ , (the probabilities of any future observations $o = \left( s ^ { \prime } , r \right)$ given a history $h$ and intervening action $a$ ) to within accuracy $o ( \delta )$ . We then show that we can again apply Assumption 1, to (almost) perfectly cluster the MDPs by true context at the end of the episode. After we collect transition probabilities at all states near the end of episode, we can construct a full transition model for each MDP.
+
+Learning the PSR to sufficient accuracy requires an additional assumption. We show that the following standard assumption on statistical sufficiency of histories and tests, is sufficient for our purposes (see also Section 2.2.1 and Appendix E.1):
+
+Assumption 2 (Sufficient Tests/Histories) Let $\tau$ and $\mathcal { H }$ be the set of all possible tests and histories of length $l = O ( 1 )$ respectively, with a given sampling policy $\boldsymbol { \mathscr { u } }$ (e.g., uniformly random policy) for histories H. $\tau$ and $\mathcal { H }$ satisfy Condition 1 and 2 respectively.
+
+![](images/64010834130c9a47e244686a6fd340f184c387d34c86da044654ea3a36f48f2e.jpg)  
+Figure 1: (a) L-UCRL when true contexts are revealed in hindsight and when we run with the EM algorithm. (b) $\mathrm { E M } + \mathrm { L }$ -UCRL (Algorithm 1) under different levels of separation and horizon length.
+
+While the worst-case instance may require $l \geq M$ to satisfy the full-rank conditions, we assume that the length of sufficient tests/histories is $l = O ( 1 )$ . In fact, $l = 1$ has been (implicitly) the common assumption in the literature on learning POMDPs [20, 5, 17, 25]. Empirically, we observe that the more MDPs differ, the more easily they satisfy Assumption 2. See Figure 2. At this point, we are not aware whether sample-efficient learning is possible with only Assumption 1.
+
+Though the main idea and key assumption are above, a few important details and technical assumptions remain to complete this story. The primary guarantee still required is that we have access to an exploration policy with sufficient mixing, to guarantee we can collect all required information to perform the PSR-based clustering. The following assumption ensures that additional ${ \tilde { O } } ( M / \alpha _ { 2 } )$ sample trajectories obtained with the exploration policy $\pi$ can provide $M$ clusters of estimated one-step predictions $\mathbb { P } _ { m } ( o | s , a )$ for every state $s$ and intervening action $a$ .
+
+Assumption 3 (Reachability of States) There exists a priori known exploration policy $\pi$ such that, for all $m \in [ M ]$ and $s \in S$ , we have $\mathbb { P } _ { m } ^ { \pi } ( s _ { H - 1 } = s ) \geq \alpha _ { 2 }$ for some $\alpha _ { 2 } > 0$ .
+
+A subtle point here is that we still have an ambiguity issue in the ordering of contexts (or labels) assigned in different states, which prevents us from recovering the full model for each context. We resolve this issues ambiguity assuming the MDP is connected, and give the full description of Algorithm 4 in Appendix E.2. We conclude this section with an (informal) end-to-end guarantee:
+
+Theorem 3.5 (Informal) Let Assumption 2 hold for an LMDP instance with a sampling policy $\pi$ . Furthermore, assume the LMDP satisfies Assumptions 1 and 3. Then there exists an algorithm such that with probability at least $2 / 3$ , it returns a good initialization of LMDP parameters that satisfies (3) in time $p o l y ( A ^ { l } , S , H , M , \sigma _ { h } ^ { - 1 } , \sigma _ { \tau } ^ { - 1 } , \alpha _ { 2 } ^ { - 1 } , \delta , \epsilon _ { i n i t } ) .$ .
+
+Theorem 3.5 completes the pipeline for learning in latent MDPs: we initialize the parameters by the estimated PSR and clustering (see Appendix E) up to some accuracy, and then we run L-UCRL to refine the model and policy up to arbitrary accuracy (Algorithm 1). Full version of Theorem 3.5 can be found in Theorem E.3.
+
+# 4 Experiments
+
+In this section, we evaluate the proposed algorithm on synthetic data. Our first two experiments illustrate the performance of L-UCRL (Algorithm 1) for various levels of separation and quality of initialization. Then, we empirically study the performance of the PSR-Clustering algorithm for randomly generated LMDPs for different levels of separation and time-horizon.
+
+# 4.1 The Value of True Contexts in Hindsight
+
+We first study the importance of receiving the true contexts in hindsight for the approach analyzed in this work, by comparing the performance of Algorithm 1 when instantiating it with Algorithm 2 or 3 as a sub-routine. We generate random instances of LMDPs of size $M = 7 , S = 1 5 , A = 3$ and set the time-horizon $H = 3 0$ . The reward distribution is set to be 0 for most state-action pairs. We compare when we give a true context to the algorithm (Algorithm 2) and when we infer a context with random initialization or good initialization (Algorithm 3). In the latter, it is equivalent to running the EM algorithm for the model estimation. For the planning algorithm, we use Q-MDP heuristic [32] which shows good empirical performance. We measure the model estimation error as $\begin{array} { r } { \begin{array} { r } { e r r o r : = \operatorname* { m i n } _ { \sigma \in  { \mathrm { P e r m } } _ { M } } \sum _ { ( m , s , a ) } \| \big (  { \mathbb { P } } _ { m } - \hat {  { \mathbb { P } } } _ { \sigma ( m ) } \big ) \big ( s ^ { \prime } , r | s , a \big ) \| _ { 1 } , } \end{array} } \end{array}$ where $ { \mathrm { P e r m } } _ { M }$ denotes all length $M$ permutation sequences. The measured errors are averaged over 10 independent experiments.
+
+![](images/cff8930457abbaef9b5c1348ebdc9c59573e1c01c0d83f7a0d7ded9c2228619b.jpg)  
+Figure 2: PSR learning and Clustering (Algorithm 4). Left: Convergence of belief state. Middle: $M ^ { t h }$ singular value of sufficient histories/tests matrix $P _ { \mathcal { T } , \mathcal { H } }$ . Right: Accuracy of the estimated model.
+
+The experimental results are given in Figure 1(a). When the true context is given at the end of episode (with Algorithm 2), L-UCRL converges to the optimal policy as our theory suggests. On the other hand, if the true context is not given (with Algorithm 3), the quality of initialization becomes crucial; when the model is poorly initialized, the estimated model converges to a local optimum which leads to a sub-optimal policy. When the model is well-initialized, L-UCRL performs as well as when true contexts are given in hindsight.
+
+# 4.2 Performance of L-UCRL with Good Initialization
+
+In our second experiment, we focus on the performance of L-UCRL (Algorithm 1) along with Algorithm 3 under different levels of separation $\delta$ in Assumption 1) when approximately good model parameters are given. For various levels of $\delta$ , we generate the parameters for transition probabilities randomly while keeping the distance between different MDPs to satisfy $\delta \leq \| ( T _ { m _ { 1 } } -$ $\bar { T } _ { m _ { 2 } } ) ( s ^ { \prime } | s , a ) \| _ { 1 } \leq 2 \delta$ for $m _ { 1 } \neq m _ { 2 }$ .
+
+We show the error in the estimated model and average long-term rewards in Figure 1(b). When the separation is sufficient (larger $\delta$ or $H$ ), the estimated model converges fast to the true parameters. When the separation gets small (smaller $\delta$ or $H$ ), the convergence speed gets slower. This type of transition in the convergence speed of EM (the update of model parameters with Algorithm 3) is observed both in theory and practice when the overlap between mixture components gets larger (e.g., [29]). On the other hand, the policy steadily improves regardless of the level of separation. We conjecture that this is because the optimal policy would only need the model to be accurate in the total-variation distance, not in the actual estimated parameters.
+
+# 4.3 Initialization with PSR and Clustering
+
+In the third experiment, we evaluate the initialization algorithm (Algorithm 4) for randomly generated LMDP instances. Since PSR learning requires a (relatively) large number of short sample trajectories, we evaluate this step on smaller instances with $S = 7 , A = 2 , M = 3$ . The LMDP instances are generated similarly as in the second experiment with different levels of $\delta$ and $H$ . The reward and initial distributions are set the same across all MDPs. To learn the parameters of PSR, we run $1 0 ^ { 6 }$ episodes with $H = 4$ . We assume histories and tests of length 1 are statistically sufficient with the uniformly random policy. In the clustering step, we run an additional $5 \cdot 1 0 ^ { 3 }$ episodes to obtain longer trajectories of length $H = 2 0 , 4 0$ and 80. We report the experimental results in Figure 2.
+
+We first observe how the level of separation $\delta$ between MDPs impacts trajectory separation, i.e., belief state vs true label (left). Recall that this separation property is the key for clustering trajectories. We then examine the performance of Algorithm 4 (see full Algorithm 5) for various levels of separation. Empirically, it succeeds to get a good initialization of an LMDP model when we have sufficient separation. As the separation level decreases, the algorithm starts to fail (Right). There are two possible sources of the failure: (1) the belief state is far from the true context, and (2) the similarity between MDPs drops the $M ^ { t h }$ singular value of $P _ { \mathcal { T } , \mathcal { H } }$ (Middle). We can compensate for (1) if we have a longer time-horizon to infer true contexts, as in the leftmost graph. For (2), if the $M ^ { t h }$ singular value drops, we require more samples for the estimation of PSR parameters. In our experiments, as we decreased $\delta$ we found that failure in the spectral learning step was the more significant of the two.
+
+# 5 Future Work
+
+There are several interesting research avenues in continuation of this work. An interesting direction is to study RL algorithms for LMDPs with no underlying assumptions. Although our lower bound suggests such an algorithm necessarily suffers an exponential dependence in the number of contexts, if this number is small, such dependence might be acceptable. Specifically, we conjecture that general LMDPs can be learned with sample complexity of poly $\left( \dot { ( } H S A ) ^ { M } , \epsilon ^ { - 1 } \right)$ . For a special case when MDPs are deterministic, we show that the exponential dependence in $\dot { M }$ is sufficient In Appendix G. The case for general LMDPs is an interesting open question. Furthermore, a needed empirical advancement is to design efficient ways to learn the set of sufficient histories/tests for learning predictive state representation of LMDPs. This can dramatically improve the performance of our algorithms when a sufficiently good initial model needs to be learned.
+
+# Acknowledgement
+
+The research was funded by NSF grant 2019844, and by the Army Research Office and was accomplished under Cooperative Agreement Number W911NF-19-2-0333. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the Army Research Office or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation herein.
+
+# References
+
+[1] A. Anandkumar, R. Ge, D. Hsu, S. M. Kakade, and M. Telgarsky. Tensor decompositions for learning latent variable models. Journal of Machine Learning Research, 15:2773–2832, 2014.   
+[2] A. Anandkumar, D. Hsu, and S. M. Kakade. A method of moments for mixture models and hidden markov models. In Conference on Learning Theory, pages 33–1, 2012.   
+[3] D. Arthur and S. Vassilvitskii. k-means $^ { + + }$ the advantages of careful seeding. In Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms, pages 1027–1035, 2007.   
+[4] M. G. Azar, I. Osband, and R. Munos. Minimax regret bounds for reinforcement learning. arXiv preprint arXiv:1703.05449, 2017.   
+[5] K. Azizzadenesheli, A. Lazaric, and A. Anandkumar. Reinforcement learning of POMDPs using spectral methods. In Conference on Learning Theory, pages 193–256, 2016.   
+[6] B. Boots and G. J. Gordon. An online spectral learning algorithm for partially observable nonlinear dynamical systems. In Twenty-Fifth AAAI Conference on Artificial Intelligence, 2011.   
+[7] B. Boots, S. M. Siddiqi, and G. J. Gordon. Closing the learning-planning loop with predictive state representations. The International Journal of Robotics Research, 30(7):954–966, 2011.   
+[8] E. Brunskill and L. Li. Sample complexity of multi-task reinforcement learning. In Uncertainty in Artificial Intelligence, page 122. Citeseer, 2013.   
+[9] P. Buchholz and D. Scheftelowitsch. Computation of weighted sums of rewards for concurrent MDPs. Mathematical Methods of Operations Research, 89(1):1–42, 2019.   
+[10] O. Cappé and E. Moulines. On-line expectation–maximization algorithm for latent data models. Journal of the Royal Statistical Society: Series B (Statistical Methodology), 71(3):593–613, 2009.   
+[11] I. Chadès, J. Carwardine, T. Martin, S. Nicol, R. Sabbadin, and O. Buffet. Momdps: a solution for modelling adaptive management problems. In Twenty-Sixth AAAI Conference on Artificial Intelligence (AAAI-12), 2012.   
+[12] C. Dann, N. Jiang, A. Krishnamurthy, A. Agarwal, J. Langford, and R. E. Schapire. On oracleefficient PAC RL with rich observations. In Advances in neural information processing systems, pages 1422–1432, 2018.   
+[13] S. Du, A. Krishnamurthy, N. Jiang, A. Agarwal, M. Dudik, and J. Langford. Provably efficient rl with rich observations via latent state decoding. In International Conference on Machine Learning, pages 1665–1674, 2019.   
+[14] A. Garivier, P. Ménard, and G. Stoltz. Explore first, exploit next: The true shape of regret in bandit problems. Mathematics of Operations Research, 44(2):377–399, 2019.   
+[15] C. Gentile, S. Li, P. Kar, A. Karatzoglou, G. Zappella, and E. Etrue. On context-dependent clustering of bandits. In International Conference on Machine Learning, pages 1253–1262. PMLR, 2017.   
+[16] C. Gentile, S. Li, and G. Zappella. Online clustering of bandits. In International Conference on Machine Learning, pages 757–765, 2014.   
+[17] Z. D. Guo, S. Doroudi, and E. Brunskill. A PAC RL algorithm for episodic POMDPs. In Artificial Intelligence and Statistics, pages 510–518, 2016.   
+[18] A. Hallak, D. Di Castro, and S. Mannor. Contextual markov decision processes. arXiv preprint arXiv:1502.02259, 2015.   
+[19] A. Hefny, C. Downey, and G. J. Gordon. Supervised learning for dynamical system learning. In Advances in neural information processing systems, pages 1963–1971, 2015.   
+[20] D. Hsu, S. M. Kakade, and T. Zhang. A spectral algorithm for learning hidden markov models. Journal of Computer and System Sciences, 78(5):1460–1480, 2012.   
+[21] T. Jaakkola, S. P. Singh, and M. I. Jordan. Reinforcement learning algorithm for partially observable markov decision problems. In Advances in neural information processing systems, pages 345–352, 1995.   
+[22] T. Jaksch, R. Ortner, and P. Auer. Near-optimal regret bounds for reinforcement learning. Journal of Machine Learning Research, 11:1563–1600, 2010.   
+[23] N. Jiang, A. Krishnamurthy, A. Agarwal, J. Langford, and R. E. Schapire. Contextual decision processes with low bellman rank are PAC-learnable. In International Conference on Machine Learning, pages 1704–1713. PMLR, 2017.   
+[24] N. Jiang, A. Kulesza, and S. Singh. Improving predictive state representations via gradient descent. In Thirtieth AAAI Conference on Artificial Intelligence, 2016.   
+[25] C. Jin, S. M. Kakade, A. Krishnamurthy, and Q. Liu. Sample-efficient reinforcement learning of undercomplete POMDPs. arXiv preprint arXiv:2006.12484, 2020.   
+[26] A. Krishnamurthy, A. Agarwal, and J. Langford. PAC reinforcement learning with rich observations. In Advances in Neural Information Processing Systems, pages 1840–1848, 2016.   
+[27] J. Kwon and C. Caramanis. The EM algorithm gives sample-optimality for learning mixtures of well-separated gaussians. In Conference on Learning Theory, pages 2425–2487, 2020.   
+[28] J. Kwon and C. Caramanis. EM converges for a mixture of many linear regressions. In International Conference on Artificial Intelligence and Statistics, pages 1727–1736, 2020.   
+[29] J. Kwon, N. Ho, and C. Caramanis. On the minimax optimality of the EM algorithm for learning two-component mixed linear regression. arXiv preprint arXiv:2006.02601, 2020.   
+[30] Y. Li, B. Yin, and H. Xi. Finding optimal memoryless policies of POMDPs under the expected average reward criterion. European Journal of Operational Research, 211(3):556–567, 2011.   
+[31] M. L. Littman. Memoryless policies: Theoretical limitations and practical results. In From Animals to Animats 3: Proceedings of the third international conference on simulation of adaptive behavior, volume 3, page 238. Cambridge, MA, 1994.   
+[32] M. L. Littman, A. R. Cassandra, and L. P. Kaelbling. Learning policies for partially observable environments: Scaling up. In Machine Learning Proceedings 1995, pages 362–370. Elsevier, 1995.   
+[33] M. L. Littman and R. S. Sutton. Predictive representations of state. In Advances in neural information processing systems, pages 1555–1561, 2002.   
+[34] Y. Liu, Z. Guo, and E. Brunskill. PAC continuous state online multitask reinforcement learning with identification. In Proceedings of the 2016 International Conference on Autonomous Agents & Multiagent Systems, pages 438–446, 2016.   
+[35] O.-A. Maillard and S. Mannor. Latent bandits. In International Conference on Machine Learning, pages 136–144, 2014.   
+[36] A. Modi, N. Jiang, S. Singh, and A. Tewari. Markov decision processes with continuous side information. In Algorithmic Learning Theory, pages 597–618, 2018.   
+[37] A. Y. Ng and M. Jordan. PEGASUS: a policy search method for large MDPs and POMDPs. In Proceedings of the Sixteenth conference on Uncertainty in artificial intelligence, pages 406–415, 2000.   
+[38] C. H. Papadimitriou and J. N. Tsitsiklis. The complexity of Markov decision processes. Mathematics of operations research, 12(3):441–450, 1987.   
+[39] J. Pineau, G. Gordon, and S. Thrun. Anytime point-based approximations for large POMDPs. Journal of Artificial Intelligence Research, 27:335–380, 2006.   
+[40] S. Ross, M. Izadi, M. Mercer, and D. Buckeridge. Sensitivity analysis of POMDP value functions. In 2009 International Conference on Machine Learning and Applications, pages 317–323. IEEE, 2009.   
+[41] S. Singh, M. R. James, and M. R. Rudary. Predictive state representations: a new theory for modeling dynamical systems. In Proceedings of the 20th conference on Uncertainty in artificial intelligence, pages 512–519, 2004.   
+[42] R. D. Smallwood and E. J. Sondik. The optimal control of partially observable markov processes over a finite horizon. Operations research, 21(5):1071–1088, 1973.   
+[43] T. Smith and R. Simmons. Heuristic search value iteration for POMDPs. In Proceedings of the 20th conference on Uncertainty in artificial intelligence, pages 520–527, 2004.   
+[44] M. T. Spaan and N. Vlassis. Perseus: Randomized point-based value iteration for POMDPs. Journal of artificial intelligence research, 24:195–220, 2005.   
+[45] L. N. Steimle, D. L. Kaufman, and B. T. Denton. Multi-model markov decision processes. Optimization Online URL http://www. optimization-online. org/DB_FILE/2018/01/6434. pdf, 2018.   
+[46] G. W. Stewart. Matrix perturbation theory. 1990.   
+[47] M. E. Taylor and P. Stone. Transfer learning for reinforcement learning domains: A survey. Journal of Machine Learning Research, 10(7), 2009.   
+[48] R. Vershynin. Introduction to the non-asymptotic analysis of random matrices. arXiv preprint arXiv:1011.3027, 2010.

parse/train/CLCVcl1rSPP/CLCVcl1rSPP_content_list.json

@@ -0,0 +1,1409 @@
+[
+    {
+        "type": "text",
+        "text": "RL for Latent MDPs: Regret Guarantees and a Lower Bound ",
+        "text_level": 1,
+        "bbox": [
+            214,
+            122,
+            785,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jeongyeol Kwon The University of Texas at Austin kwonchungli@utexas.edu ",
+        "bbox": [
+            243,
+            222,
+            464,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yonathan Efroni Microsoft Research, NYC jonathan.efroni@gmail.com ",
+        "bbox": [
+            539,
+            222,
+            754,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Constantine Caramanis The University of Texas at Austin constantine@utexas.edu ",
+        "bbox": [
+            245,
+            285,
+            465,
+            327
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Shie Mannor Technion, NVIDIA shie@ee.technion.ac.il, smannor@nvidia.com ",
+        "bbox": [
+            544,
+            285,
+            741,
+            340
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            376,
+            535,
+            392
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we consider the regret minimization problem for reinforcement learning in latent Markov Decision Processes (LMDP). In an LMDP, an MDP is randomly drawn from a set of $M$ possible MDPs at the beginning of the interaction, but the identity of the chosen MDP is not revealed to the agent. We first show that a general instance of LMDPs requires at least $\\Omega ( ( S A ) ^ { M } )$ episodes to even approximate the optimal policy. Then, we consider sufficient assumptions under which learning good policies requires polynomial number of episodes. We show that the key link is a notion of separation between the MDP system dynamics. With sufficient separation, we provide an efficient algorithm with local guarantee, i.e., providing a sublinear regret guarantee when we are given a good initialization. Finally, if we are given standard statistical sufficiency assumptions common in the Predictive State Representation (PSR) literature (e.g., [6]) and a reachability assumption, we show that the need for initialization can be removed. ",
+        "bbox": [
+            233,
+            410,
+            766,
+            589
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            621,
+            310,
+            638
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Partially observable Markov decision processes (POMDPs) [42] give a general framework to describe partially observable sequential decision problems. In POMDPs, the underlying dynamics satisfy the Markovian property, but the observations give only partial information on the identity of the underlying states. With the generality of this framework comes a high computational and statistical price to pay: POMDPs are hard, primarily because optimal policies depend on the entire history of the process. But for many important problems, this full generality can be overkill, and in particular, does not have a way to leverage special structure. We are interested in settings where the hidden or latent (unobserved) variables have slow dynamics or are even static in each episode. This model is important for diverse applications, from serving a user in a dynamic web application [18], to medical decision making [45], to transfer learning in different RL tasks [8]. Yet, as we explain below, even this area remains little understood, and challenges abound. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            808
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Thus, in this work, we consider reinforcement learning (RL) for a special type of POMDP which we call a latent Markov decision process (LMDP). LMDPs consist of some (perhaps large) number $M$ of MDPs with joint state space $s$ and actions $\\mathcal { A }$ . In episodic LMDPs with finite time-horizon $H$ , the static latent (hidden) variable that selects one of $M$ MDPs is randomly chosen at the beginning of each episode, yet is not revealed to the agent. The agent then interacts with the chosen MDP throughout the episode (see Definition 1 for the formal description). ",
+        "bbox": [
+            174,
+            814,
+            825,
+            897
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Related Work. The LMDP framework has previously been introduced under many different names, e.g., hidden-model MDP [11], Multitask RL [8], Contextual MDP [18], Multi-modal Markov decision process [45] and Concurrent MDP [9]. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            133
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning in LMDPs is a challenging problem due to the unobservability of latent contexts. For instance, the exact planning problem is P-SPACE hard [45], inheriting the hardness of planning from the general POMDP framework. Nevertheless, the lack of dynamics of the latent variables, offers some hope. As an example, if the number of contexts $M$ is bounded, then the planning problem can be at least approximately solved (e.g., by point-based value iteration (PBVI) [39], or mixed integer programming (MIP) [45]). ",
+        "bbox": [
+            174,
+            140,
+            825,
+            223
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The most closely related work studying LMDPs is in the context of multitask RL [47, 8, 34, 18]. In this line of work, a common approach is to cluster trajectories according to different contexts, an approach that guided us in designing the algorithms in Section 3.4. However, previous work requires very long time-horizon $H \\gg S A$ in order to guarantee that every state-action pair can be visited multiple times in a single episode. In contrast, we consider a significantly shorter time-horizon that scales poly-logarithmic with the number of states, i.e., $H = p o l y \\bar { \\log ( M S \\dot { A } ) }$ . This short time-horizon results in a significant difference in learning strategy even when we get a feedback on the true context at the end of episode. We refer the readers to Appendix A for additional discussion on related work. ",
+        "bbox": [
+            174,
+            229,
+            825,
+            340
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Main Results. To the best of our knowledge, none of the previous literature has obtained sample complexity guarantees or studied regret bounds in the LMDP setting. This paper addresses precisely this problem. We ask the following: ",
+        "bbox": [
+            174,
+            345,
+            825,
+            388
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Is there a sample efficient RL algorithm for LMDPs, with sublinear regret? ",
+        "bbox": [
+            253,
+            400,
+            743,
+            415
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The answer turns out to be not so simple. Our results comprise a first impossibility result, followed by positive algorithmic results under additional assumptions. Specifically: ",
+        "bbox": [
+            173,
+            428,
+            823,
+            455
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• First, we find that for a general LMDP, polynomial sample complexity cannot be attained without further assumptions. That is, to find an approximately optimal policy we need at least $\\Omega \\left( ( S A ) ^ { M } \\right)$ samples, i.e., at least exponential in the number of contexts $M$ (Section 3.1). This lower bound even applies to instances with deterministic MDPs.   \n• We find that there are several natural assumptions under which optimal policies can be learned with polynomial sample complexity. Similarly to mixture problems without dynamics, the key link is a notion of separation between the MDPs. With sufficient separation, we show that there is a planning-oracle efficient RL algorithm with polynomial sample complexity. A critical development is adapting the principle of optimism as in UCB, but to the partially observed setting where value-iteration cannot be directly applied, and thus neither can the UCRL algorithm for MDPs.   \n• Finally, under additional statistical sufficiency assumptions that are common in the Predictive State Representation (PSR) literature (e.g., [6]) and a reachability assumption, we show that the need for initialization can be entirely removed.   \n• Finally, we perform an empirical evaluation of the suggested algorithms on toy problems (Section 4), while focusing on the importance of the made assumptions. ",
+        "bbox": [
+            173,
+            468,
+            826,
+            699
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            719,
+            318,
+            737
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Problem Setup: Latent MDPs ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            752,
+            419,
+            767
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We start with the definition of episodic reinforcement learning in latent Markov decision process: ",
+        "bbox": [
+            171,
+            779,
+            808,
+            794
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Definition 1 (Latent Markov Decision Process (LMDP)) Consider a set of MDPs $\\mathcal { M }$ with joint state space $s$ and joint action space $\\mathcal { A }$ in a finite time horizon $H$ . Let $M = | { \\mathcal { M } } |$ , $S = | S |$ and $A = | { \\mathcal { A } } |$ . Each MDP $\\mathcal { M } _ { m } \\in \\mathcal { M }$ is a tuple $( \\mathcal { S } , \\mathcal { A } , T _ { m } , R _ { m } , \\nu _ { m } )$ where $T _ { m } : S \\times A \\times S  [ 0 , 1 ]$ a transition probability maps a state-action pair and a next state to a probability, ${ R _ { m } } : S \\times A \\times \\{ 0 , 1 \\} \\to [ 0 , 1 ]$ a probability measure for rewards that maps a state-action pair and a binary reward to a probability, and $\\nu _ { m }$ is an initial state distribution. Let $w _ { 1 } , . . . , w _ { M }$ be the mixing weights of LMDPs such that at the start of every episode, one MDP $\\mathcal { M } _ { m } \\in \\mathcal { M }$ is randomly chosen with probability $w _ { m }$ . ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We assume the mixing weights are uniform and known a priori, i.e., $w _ { 1 } = . . . = w _ { M } = 1 / M$ . This is only for the ease of presentation, and does not affect any algorithmic idea or main results in this paper. The goal of the problem is to Π that maximizes the expected return: $\\pi$ n a pol ,where ssis $\\begin{array} { r } { V _ { { \\mathcal { M } } } ^ { * } : = \\operatorname* { m a x } _ { \\pi \\in \\Pi } \\sum _ { m = 1 } ^ { M } w _ { m } \\mathbb { E } _ { m } ^ { \\pi } \\left[ \\sum _ { t = 1 } ^ { H } r _ { t } \\right] } \\end{array}$ $\\mathbb { E } _ { m } ^ { \\pi } [ \\cdot ]$ expectation taken over the $m ^ { t h }$ MDP with a policy $\\pi$ . If not specified otherwise, we find the best policy in a set of history-dependent policies $\\bar { \\pi } : ( \\bar { S } , \\mathcal { A } , \\{ 0 , 1 \\} ) ^ { * } \\times \\mathcal { S }  \\Delta ( A )$ that map an entire history to a probability distribution over actions. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            200
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We define the notion of regret relative to a (possibly approximate) planning oracle. Thus, suppose we have a planning-oracle with the following approximation guarantee: $V _ { \\mathcal { M } } ^ { \\pi } \\geq \\rho _ { 1 } V _ { \\mathcal { M } } ^ { * } - \\rho _ { 2 }$ , where $\\pi$ is a returned policy when $\\mathcal { M }$ is given to the planning-oracle, and $\\rho _ { 1 } , \\rho _ { 2 }$ are multiplicative and additive approximation constants respectively. We then define the regret as the comparison to the best approximation guarantee that the planning-oracle can achieve: ",
+        "bbox": [
+            173,
+            205,
+            825,
+            275
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4da694c98ebef641d667d5c01a0b95289e5b54075c880f76fcc456c47b78a668.jpg",
+        "text": "$$\nR e g r e t ( K ) = \\sum _ { k = 1 } ^ { K } ( \\rho _ { 1 } V _ { \\mathcal { M } } ^ { * } - \\rho _ { 2 } ) - V _ { \\mathcal { M } } ^ { \\pi _ { k } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            281,
+            633,
+            325
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\pi _ { k }$ is a policy executed in the $k ^ { t h }$ episode. For example, we can use point-based value-iteration (PBVI) [39] as a planning-oracle: ",
+        "bbox": [
+            173,
+            332,
+            820,
+            362
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Example 1 PBVI [39] with discretization level $\\epsilon _ { d } > 0$ in the belief space (over $\\mathbb { R } ^ { M }$ ) returns an $\\epsilon _ { d } H ^ { 2 }$ additive approximate policy. That is, equation (1) holds with $\\rho _ { 1 } = 1$ and $\\rho _ { 2 } = \\epsilon _ { d } H ^ { 2 }$ . ",
+        "bbox": [
+            171,
+            375,
+            823,
+            405
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Predictive State Representation (PSR) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            419,
+            478,
+            435
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A partially observable dynamical system can be viewed as a model that generates a sequence of observations from observation space $\\mathcal { O }$ with (controlled) actions from action space $\\mathcal { A }$ . A predictive state representation (PSR) is a compact description of a dynamical system with a set of observable experiments, or tests [41]. Specifically, a test of length $t$ is a sequence of action-observation pairs given as $\\tau = { a _ { 1 } ^ { \\tau } o _ { 1 } ^ { \\tau } o _ { 2 } ^ { \\tau } . . . a _ { t } ^ { \\tau } o _ { t } ^ { \\tau } }$ . A history $h = a _ { 1 } ^ { h } o _ { 1 } ^ { h } a _ { 2 } ^ { \\tilde { h _ { } } } o _ { 2 } ^ { h } . . . a _ { t } ^ { h } o _ { t } ^ { h }$ is a sequence of action-observation pairs that has been generated prior to a given time. A prediction $\\mathbb { P } ( \\tau | h ) { \\overset { - } { = } } \\mathbb { P } ( o _ { 1 : t } ^ { \\tau } | h | | d o a _ { 1 : t } ^ { \\tau } )$ denotes the probability of seeing the test sequence from a given history, given that we intervene to take actions $a _ { 1 } ^ { \\tau } a _ { 2 } ^ { \\tau } . . . a _ { t } ^ { \\tau }$ . In latent MDPs, the observation space can be considered as a pair of next-states and rewards, i.e., ${ \\mathcal { O } } = { \\mathcal { S } } \\times \\{ 0 , 1 \\}$ and $o _ { t } = \\left( s _ { t + 1 } , r _ { t } \\right)$ . ",
+        "bbox": [
+            173,
+            444,
+            825,
+            571
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As we work with a special class of POMDPs, we customize the formulation for LMDPs. The set of histories consists of a subset of histories that end with different states, i.e., $\\textstyle { \\mathcal { H } } = \\bigcup _ { s } { \\mathcal { H } } _ { s }$ , where each element $h \\in \\mathcal { H } _ { s }$ is a short sequence of state-action-rewards of length $l$ ending with state $s$ : ",
+        "bbox": [
+            173,
+            575,
+            826,
+            618
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/845fc4ea85af94a9a6b508613844cbd5c0a370f7c07098883301c5c7f5f3c33e.jpg",
+        "text": "$$\nh = s _ { 1 } ^ { h } a _ { 1 } ^ { h } r _ { 1 } ^ { h } s _ { 2 } ^ { h } . . . s _ { l - 1 } ^ { h } a _ { l - 1 } ^ { h } r _ { l - 1 } ^ { h } s = ( s , a , r ) _ { 1 : l - 1 } ^ { h } s .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            625,
+            661,
+            645
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We define $\\mathbb { P } _ { m } ^ { \\pi } ( \\mathcal { H } _ { s } )$ a vector of probabilities where each coordinate is a probability of sampling each history in $\\mathcal { H } _ { s }$ in the $m ^ { t h }$ MDP with a policy $\\pi$ . Likewise, each element in tests $\\tau \\in \\mathcal { T }$ is a short sequence of action-reward-next states of length at most $l$ : ",
+        "bbox": [
+            173,
+            650,
+            826,
+            693
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/704815527f3474922414bebdfab055a972890ed660c777cd54d3efc2ef4a1525.jpg",
+        "text": "$$\n\\tau = a _ { 1 } ^ { \\tau } r _ { 1 } ^ { \\tau } s _ { 2 } ^ { \\tau } . . . a _ { l } ^ { \\tau } r _ { l } ^ { \\tau } s _ { l + 1 } ^ { \\tau } = ( a , r , s ^ { \\prime } ) _ { 1 : l } ^ { \\tau } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            699,
+            625,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We denote $\\mathbb { P } _ { m } ( \\mathcal { T } | s )$ as a vector of probability where each coordinate is a success probability of each test in the $m ^ { t h }$ MDP starting from a state $s$ . That is, ",
+        "bbox": [
+            173,
+            723,
+            825,
+            753
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/21ab72441a416a75175efa966ffc494d79f8427e23c12d57fa91cce3560c9161.jpg",
+        "text": "$$\n\\mathbb { P } _ { m } ( \\mathcal { T } | s ) _ { i } = \\mathbb { P } _ { m } \\big ( r _ { 1 } ^ { \\tau _ { i } } s _ { 2 } ^ { \\tau _ { i } } . . . r _ { l } ^ { \\tau _ { i } } s _ { l + 1 } ^ { \\tau _ { i } } | s | \\big | d o a _ { 1 } ^ { \\tau _ { i } } . . . a _ { l } ^ { \\tau _ { i } } \\big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            758,
+            666,
+            777
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2.1 Spectral Learning of PSRs in LMDPs ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            789,
+            486,
+            804
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In spectral learning, we build a set of observable matrices that contains the (joint) probabilities of histories and tests, and then we can extract parameters from these matrices by performing singular value decomposition (SVD) and regressions [7]. In order to apply spectral learning techniques, we require the following technical conditions on statistical sufficiency of tests: ",
+        "bbox": [
+            174,
+            813,
+            826,
+            869
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Condition 1 (Sufficient Tests) For all $ { \\mathcal { S } } _ { s } \\in  { \\mathcal { S } } _ { }$ , for the test set $\\tau$ , let $\\begin{array} { r l } { L _ { s } } & { { } = } \\end{array}$ $[ \\mathbb { P } _ { 1 } ( \\pmb { \\mathscr { T } } | s ) | \\mathbb { P } _ { 2 } ( \\pmb { \\mathscr { T } } | s ) | . . . | \\mathbb { P } _ { M } ( \\pmb { \\mathscr { T } } | s ) ]$ . Then $\\sigma _ { M } ( L _ { s } ) \\geq \\sigma _ { \\tau }$ for all $s \\in S$ with some $\\sigma _ { \\tau } > 0$ . ",
+        "bbox": [
+            173,
+            882,
+            825,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\sigma _ { M } ( \\cdot )$ is the minimum $( M ^ { t h } )$ singular value of a matrix. Another technical condition for spectral learning method is a rank non-degeneracy condition for sufficient histories: ",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Condition 2 (Sufficient Histories) For all $s \\in \\mathcal { S }$ , for the history set $\\mathcal { H } _ { s }$ ending with a state $s$ , let $H _ { s } \\ = \\ [ \\mathbb { P } _ { 1 } ^ { \\pi } ( \\mathcal { H } _ { s } ) | \\mathbb { P } _ { 2 } ^ { \\pi } ( \\mathcal { H } _ { s } ) | . . . | \\mathbb { P } _ { M } ^ { \\pi } ( \\mathcal { H } _ { s } ) ] ^ { \\intercal }$ with a sampling policy $\\pi$ . Then $\\sigma _ { M } ( L _ { s } H _ { s } ) \\geq $ $\\mathbb { P } ^ { \\pi } ( e n d s t a t e = s ) \\cdot \\sigma _ { h }$ with some $\\sigma _ { h } > 0$ . ",
+        "bbox": [
+            174,
+            132,
+            825,
+            175
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here $\\mathbb { P } ^ { \\pi }$ (end state $= s$ ) is a probability of sampling a history ending with $s$ . Along with the rank condition for tests, pairs of histories and tests can be thought as many short snap-shots of long trajectories obtained by external experts or some exploration policy (e.g., random policy in uniformly ergodic MDPs). Following the notations in [7], let $P _ { \\tau , \\mathcal { H } _ { s } } = L _ { s } H _ { s }$ . Conditions 1 and 2 ensure $\\bar { \\sigma _ { M } } ( P _ { T , \\mathcal { H } _ { s } } ) > 0$ . Under these conditions, the goal of spectral learning algorithm is to output PSR parameters which are used to compute ${ \\hat { \\mathbb { P } } } ( \\tau | h )$ , the estimated probability of any future observations (or tests $\\tau$ ) given any sampled histories $h$ . We refer to Appendix E.1 for a detailed procedure. ",
+        "bbox": [
+            174,
+            190,
+            825,
+            291
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 Notations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            308,
+            281,
+            321
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We denote the underlying LMDP with true parameters as $\\mathcal { M } ^ { * }$ . With slight abuse of notation, we denote the $l _ { 1 }$ distance between two probability distributions $\\mathcal { D } _ { 1 }$ and $\\mathcal { D } _ { 2 }$ on a random variable $X$ conditioned on event $E$ as $\\begin{array} { r } { \\| ( \\mathbb { P } _ { X \\sim \\mathcal { D } _ { 1 } } - \\mathbb { P } _ { X \\sim \\mathcal { D } _ { 2 } } ) ( X | E ) \\| _ { 1 } = \\sum _ { X \\in \\mathcal { X } } | \\mathbb { P } _ { X \\sim \\mathcal { D } _ { 1 } } ( X | E ) - \\mathbb { P } _ { X \\sim \\mathcal { D } _ { 2 } } ( X | E ) | } \\end{array}$ , where $\\mathcal { X }$ is a support of $X$ . When we do not condition on any event, we omit the conditioning on $E$ . When we measure a transition or reward probability at a state-action pair $( s , a )$ , we use $T$ or $R$ instead of $\\mathbb { P }$ . We use $\\mathbb { P } _ { m }$ to refer to the probability of any event measured in the $m ^ { t h }$ context (or in $m ^ { t h }$ MDP). In particular, $\\mathbb { P } _ { m } ( s ^ { \\prime } , r | s , \\bar { a } ) = T _ { m } \\bar { ( } s ^ { \\prime } | s , a ) R _ { m } ( r | s , a )$ . If we use $\\mathbb { P }$ without any subscript, it is a probability of an event measured outsidethe probability of an event depends on a policy f the context, i.e., , we add superscri $\\begin{array} { r } { \\mathbb { P } ( \\cdot ) = \\sum _ { m = 1 } ^ { M } w _ { m } \\mathbb { P } _ { m } ( \\cdot ) } \\end{array}$ Ifis $\\pi$ $\\pi$ $\\mathbb { P }$ $\\mathbb { E } _ { m } [ \\cdot ]$ expectation taken over the $m ^ { t h }$ context and $\\pi$ is added as superscript if the expectation depends on $\\pi$ . We use ˆ· to denote any estimated quantities. $a \\lesssim b$ implies $a$ is less than $b$ up to some constant and logarithmic factors. $p o l y ( \\cdot )$ means the order of polynomial complexity (up to logarithmic factors) in referenced parameters. We interchangeably use $o$ , an observation, to replace a pair of next-state and immediate reward $( s ^ { \\prime } , r )$ to simplify the notation. We occasionally express a length $t > 0$ history $( s _ { 1 } , a _ { 1 } , r _ { 1 } , . . . , s _ { t } , a _ { t } , r _ { t } )$ compactly as $( s , a , r ) _ { 1 : t }$ . ",
+        "bbox": [
+            173,
+            333,
+            826,
+            546
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Main Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            564,
+            315,
+            582
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first obtain a hardness result for the general case. We then consider sample- and computationally efficient algorithms under additional assumptions. ",
+        "bbox": [
+            174,
+            595,
+            823,
+            625
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Fundamental Limits of Learning General LMDPs ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            640,
+            560,
+            655
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We first study the fundamental limits of the problem. In particular, we are interested in whether we can learn the optimal policy after interacting with the LMDP for a number of episodes polynomial in the problem parameters. We prove a worst-case lower bound, exhibiting an instance of LMDP that requires at least $\\Omega \\left( ( S A ) ^ { M } \\right)$ episodes: ",
+        "bbox": [
+            174,
+            665,
+            825,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.1 (Lower Bound) There exists an LMDP such that for finding an \u000f-optimal policy $\\pi _ { \\epsilon }$ for which $V _ { \\mathcal { M } } ^ { \\pi _ { \\epsilon } } \\geq V _ { \\mathcal { M } } ^ { * } - \\epsilon$ , we need at least $\\Omega \\left( ( S A / M ) ^ { M } / \\epsilon ^ { 2 } \\right)$ episodes. ",
+        "bbox": [
+            174,
+            734,
+            821,
+            765
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The hard instance consists of fully deterministic MDPs with possibly stochastic rewards, indicating an exponential lower bound in the number of contexts even for the easiest types of LMDPs. The example is constructed such that, in the absence of knowing true contexts, all wrong action sequences of length $M$ cannot provide any information with zero reward, whereas the only correct action sequence gets a total reward of 1 under one specific context. The construction is given in Appendix B. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.1 prevents a design of efficient algorithms with growing number of contexts. We note here that Theorem 3.1 holds even for restricted classes of policies, e.g., memoryless policies. Furthermore, our construction of hard instances does not allow to find any approximate policy with $\\rho _ { 1 } = \\omega ( ( S A ) ^ { - M } )$ within a polynomial number of episodes either. To the best of our knowledge, this ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Initialize visit counts $N _ { m } ( s , a ) , N ( m )$ and parameters $( \\hat { T } _ { m } , \\hat { R } _ { m } , \\hat { \\nu } _ { m } )$ properly ",
+        "bbox": [
+            174,
+            109,
+            671,
+            126
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1: for each $k ^ { t h }$ episode do   \n2: Get a policy $\\pi _ { k }$ for $\\widetilde { \\mathcal { M } } _ { k }$ in Lemma 3.2   \n3: Play policy $\\pi _ { k }$ and get the trajectory $\\tau = ( s , a , r ) _ { 1 : H }$   \n4: Get an estimated belief over contexts $\\hat { b }$ with either Algorithm 2 (when contexts are given), or   \nAlgorithm 3 (when we infer contexts)   \n5: for $m = 1 , . . . , M$ and $t = 1 , . . . , H$ do   \n6: $N _ { m } ( s _ { t + 1 } | a _ { t } , s _ { t } ) \\gets N _ { m } ( s _ { t + 1 } | a _ { t } , s _ { t } ) + \\hat { b } ( m )$   \n7: $N _ { m } ( r _ { t } | s _ { t } , a _ { t } ) \\gets N _ { m } ( r _ { t } | s _ { t } , a _ { t } ) + \\hat { b } ( m )$   \n8: $N _ { m } ( s _ { 1 } ) \\gets N _ { m } ( s _ { 1 } ) + \\hat { b } ( m )$   \n9: Update empirical parameters $\\hat { T } _ { m } , \\hat { R } _ { m } , \\hat { \\nu } _ { m }$   \n10: end for   \n11: end for ",
+        "bbox": [
+            178,
+            128,
+            826,
+            311
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "is the first lower bound of its kind for LMDPs. Next, we investigate natural assumptions which help us to develop an efficient algorithm when only polynomial number of episodes are available. ",
+        "bbox": [
+            174,
+            337,
+            825,
+            366
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 The Critical First Step: Contexts in Hindsight ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            381,
+            532,
+            397
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Suppose the true context of the underlying MDP is revealed to the agent at the end of each episode. We do not require any assumptions on the environments in this scenario. Note that this scenario is different from fully observable settings (i.e., knowing the true context at the beginning of an episode). In the latter scenario, we would simply have $M$ -decoupled RL problems in standard MDPs. While this can be considered as a “warm-up” for the sequel, it is motivated by real-world examples. Moreover, the key technical insight here will prove important for the sequel as well. ",
+        "bbox": [
+            173,
+            406,
+            826,
+            491
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Knowing contexts in hindsight allows us to construct a confidence set for parameters: ",
+        "bbox": [
+            174,
+            497,
+            730,
+            512
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/da90c1066e39b72216ba1faada7344f3fa1fcb2a270feccf8b29472fbee00fbd.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { C } = \\{ \\mathcal { M } \\ | \\| ( \\nu _ { m } - \\hat { \\nu } _ { m } ) ( s ) \\| _ { 1 } \\leq \\sqrt { c _ { \\nu } / N ( m ) } , \\ \\| ( T _ { m } - \\hat { T } _ { m } ) ( s ^ { \\prime } | s , a ) \\| _ { 1 } \\leq \\sqrt { c _ { T } / N _ { m } ( s , a ) } , } \\\\ { \\| ( R _ { m } - \\hat { R } _ { m } ) ( r | s , a ) \\| _ { 1 } \\leq \\sqrt { c _ { R } / N _ { m } ( s , a ) } , \\quad \\forall m , s , a \\} , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            205,
+            515,
+            789,
+            560
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $N _ { m } ( s , a )$ is the number of times each state-action pair $( s , a )$ in $m ^ { t h } ~ \\mathrm { { M D P } }$ is visited, and $N ( m )$ is the number of episodes we interact with the $m ^ { t h }$ MDP. With properly set parameters $\\dot { c _ { T } } = { \\cal O } ( S \\log ( K / \\eta ) ) , c _ { R } \\dot { = } { \\cal O } ( \\log ( K / \\eta ) )$ and $c _ { \\nu } = O ( S \\log ( K / \\eta ) )$ for the confidence intervals, $\\mathcal { M } ^ { \\ast } \\in \\mathcal { C }$ with high probability for all $K$ episodes. ",
+        "bbox": [
+            173,
+            565,
+            826,
+            622
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "With the construction of confidence sets, it is then natural to try to design an optimistic RL algorithm, as in UCRL [22]. An obvious optimistic value in light of (2) is $\\operatorname* { m a x } _ { \\pi } { } , \\mathcal { M } \\in \\mathcal { C }  \\ : V _ { \\mathcal { M } } ^ { \\pi }$ . However, solving this optimization problem is more general than solving an LMDP. In fully observable settings, we could replace the complex optimization problem by adding a proper exploration bonus to obtain an optimistic value function [4]. ",
+        "bbox": [
+            173,
+            628,
+            825,
+            699
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In partially observable environments, value iteration is only defined in terms of belief-states and not the observed states. For this reason, existing techniques solely based on the value-iteration cannot be directly applied for LMDPs. Yet, we find that proper analysis of the Bellman update rule over the belief state reveals that an empirical LMDP with properly adjusted hidden rewards is optimistic: ",
+        "bbox": [
+            173,
+            704,
+            825,
+            761
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proposition 3.2 We construct an optimistic LMDP $\\widetilde { \\mathcal { M } }$ whose parameters are given such that: ",
+        "bbox": [
+            171,
+            773,
+            787,
+            791
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d8d08918b1819731a2431b3b04006c33a3aab83cf74aad4924d0e5d98551dec9.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\widetilde { T } _ { m } ( s ^ { \\prime } | s , a ) = \\hat { T } _ { m } ( s ^ { \\prime } | s , a ) , \\ \\widetilde { R } _ { m } ^ { o b s } ( r | s , a ) = \\hat { R } _ { m } ( r | s , a ) , \\ \\widetilde { \\nu } _ { m } ( s ) = \\hat { \\nu } _ { m } ( s ) , } \\\\ & { \\widetilde { R } _ { i n i t } ^ { h i d } ( m ) = \\operatorname* { m i n } \\left( 1 , \\sqrt { c _ { \\nu } / N ( m ) } \\right) \\ \\widetilde { R } _ { m } ^ { h i d } ( s , a ) = H \\operatorname* { m i n } \\left( 1 , \\sqrt { 5 \\left( c _ { R } + c _ { T } \\right) / N _ { m } ( s , a ) } \\right) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            207,
+            795,
+            787,
+            845
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\widetilde { R } _ { i n i t } ^ { h i d } ( m )$ is an initial hidden reward given when starting an episode with a context $m$ , and $\\widetilde { R } _ { m } ^ { o b s } ( \\cdot | s , a )$ is a probability measure of an observable immediate reward $r$ whereas $\\widetilde { R } _ { m } ^ { h i d } ( s , a )$ is $a$ hidden immediate reward (that is not visible to the agent) for a state-action pair $( s , a )$ in a context $m$ . Then for any policy $\\pi$ , the expected long-term reward is optimistic, i.e., $V _ { \\widehat { \\mathcal { M } } } ^ { \\pi } \\geq V _ { \\mathcal { M } ^ { \\ast } } ^ { \\pi }$ . ",
+        "bbox": [
+            173,
+            851,
+            826,
+            915
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Access to True Contexts ",
+        "bbox": [
+            186,
+            106,
+            434,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Input: Receive true context $m ^ { * }$ in hindsight ",
+        "bbox": [
+            184,
+            123,
+            459,
+            150
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Output : Belief over hidden contexts: ",
+        "bbox": [
+            187,
+            151,
+            436,
+            165
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/36628d690dd66559f8e7739797f1496cc6a651266169b9a119a9056e8b6d566d.jpg",
+        "text": "$$\n\\hat { b } ( m ) = \\left\\{ \\begin{array} { l l } { { 1 , } } & { { \\mathrm { f o r } m = m ^ { * } } } \\\\ { { 0 , } } & { { \\mathrm { f o r } m \\ne m ^ { * } } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            222,
+            175,
+            413,
+            205
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 3 Inference of Contexts ",
+        "text_level": 1,
+        "bbox": [
+            470,
+            106,
+            697,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Input: Trajectory $\\tau = ( s _ { 1 } , a _ { 1 } , r _ { 1 } , . . . , s _ { H } , a _ { H } , r _ { H } )$ Output: Return an estimate of belief over contexts $\\hat { b }$ : ",
+        "bbox": [
+            467,
+            123,
+            808,
+            165
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/79d31a64181d8b3e8acafed85dbd163672163aa60a6d51b0d18467c267805aff.jpg",
+        "text": "$$\n\\begin{array} { l } { \\hat { p } _ { m } ( \\tau ) = \\Pi _ { t = 1 } ^ { H } ( \\alpha + ( 1 - 2 \\alpha S ) \\hat { \\mathbb { P } } _ { m } ( s _ { t + 1 } , r _ { t } | s _ { t } , a _ { t } ) ) , } \\\\ { \\hat { b } ( m ) = \\frac { \\hat { p } _ { m } ( \\tau ) } { \\sum _ { m = 1 } ^ { M } \\hat { p } _ { m } ( \\tau ) } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            467,
+            165,
+            812,
+            226
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here, hidden reward is a deterministic reward that happens for every state-action pair, but does not appear in any observation history during the episode. We note that most existing planning algorithms can incorporate the hidden-reward structure without changes to maximize the long-term observed $^ +$ hidden rewards. For instance, the PBVI algorithm [39] can be executed as it is in the planning step. Hence in each episode, we can build one optimistic model from Proposition 3.2, and call the planning-oracle to get a policy to execute for the episode. Then we simply run the policy and update model parameters in a straight-forward manner. The algorithm can be efficiently implemented as long as some efficient (approximate) planning algorithms are available. ",
+        "bbox": [
+            173,
+            243,
+            825,
+            356
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To establish Proposition 3.2, we make use of the ‘alpha vector’ representation [42] of the value function of general POMDPs. Detailed analysis is deferred to Appendix C.1. With the optimistic model constructed in Proposition 3.2, planning-oracle efficient implementation is straightforward. The resulting latent upper confidence reinforcement learning (L-UCRL) algorithm is summarized in Algorithm 1. Based on the established optimism in Proposition 3.2 and by carefully bounding the on-policy errors we arrive to the following regret guarantee of L-UCRL. ",
+        "bbox": [
+            173,
+            361,
+            825,
+            445
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.3 Let $N = H K$ . The regret of the Algorithm 1 is bounded by: ",
+        "bbox": [
+            176,
+            457,
+            661,
+            472
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d489dcadc5b71b5d6c6087f89b31937ac94db417da40257874e95da81c307203.jpg",
+        "text": "$$\nR e g r e t ( K ) \\leq \\sum _ { k = 1 } ^ { K } ( V _ { \\widehat { \\mathcal { M } } _ { k } } ^ { \\pi _ { k } } - V _ { \\mathcal { M } ^ { * } } ^ { \\pi _ { k } } ) \\lesssim H S \\sqrt { M A N } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            472,
+            666,
+            515
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proof of Theorem 3.3 is given in Appendix C.4. The central result of this section, Theorem 3.3 leads to the following observation: a polynomial sample complexity is possible for the LMDP model assuming the context of the underlying MDP is supplied at the end of each episode. Next, we explore ways to relax this assumption, while keep supplying with a polynomial sample complexity guarantee. ",
+        "bbox": [
+            174,
+            527,
+            826,
+            584
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 When we can Infer Contexts? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            599,
+            416,
+            614
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Without explicit access to the true context at the end of an episode, it is natural to estimate the context from the sampled trajectory. One sufficient condition to infer the context is the following: ",
+        "bbox": [
+            174,
+            625,
+            823,
+            654
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Assumption 1 $\\boldsymbol { \\delta }$ -Strongly Separated MDPs) For all $m$ , $m _ { 1 } , m _ { 2 } \\in [ M ]$ such that $m _ { 1 } \\neq m _ { 2 }$ , for all $( s , a ) \\in \\mathcal { S } \\times \\mathcal { A } , l$ $l _ { 1 }$ distance between probability of observations $o = \\bar { ( \\boldsymbol { s } ^ { \\prime } , \\boldsymbol { r } ) }$ of two different $M D P s$ in $L M D P$ is at least $\\delta > 0$ , i.e., $\\| ( \\mathbb { P } _ { m _ { 1 } } - \\mathbb { P } _ { m _ { 2 } } ) ( o | s , a ) \\| _ { 1 } \\geq \\delta$ for some constant $\\delta > 0$ . ",
+        "bbox": [
+            174,
+            665,
+            825,
+            709
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In order to reliably infer the true contexts the seperatedness between MDPs alone is not sufficient, since we need to estimate the contexts from the current empirical estimates of LMDPs. In order to reliably estimate the context from empirical estimate of LMDPs, we need a well-initialized empirical transition model of the LMDP: ",
+        "bbox": [
+            173,
+            723,
+            825,
+            779
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/af360135cc202d03b5d71c50149c3b66d65e1f2d9661a35592630f2b65f64e7b.jpg",
+        "text": "$$\n\\| ( \\hat { T } _ { m } - T _ { m } ) ( s ^ { \\prime } | s , a ) \\| _ { 1 } , \\ \\| ( \\hat { \\nu } _ { m } - \\nu _ { m } ) ( s ) \\| _ { 1 } , \\ \\| ( \\hat { R } _ { m } - R _ { m } ) ( r | s , a ) \\| _ { 1 } \\leq \\epsilon _ { i n i t } , \\qquad \\forall ( s , a ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            781,
+            784,
+            801
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "for some initialization error $\\epsilon _ { i n i t } > 0$ . Note that while the initialization error is relatively small, it can be still not good enough to obtain a near-optimal policy (i.e., it will result in a linear regret). We can consider as if the state-action pairs are already visit at least $N _ { 0 } = c _ { T } / \\epsilon _ { i n i t } ^ { 2 }$ times in each context. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            848
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Once the initialization is given along with separation between MDPs, we can modify Algorithm 1 to update the empirical estimate of LMDP using the estimated belief over contexts computed in Algorithm 3. Note that when we update the model parameters, we increase the visit count of stateaction pair $( s , a )$ at $m ^ { t h }$ MDP by $\\hat { b } ( m )$ . With Assumption 1, it approximately adds a count for the correctly estimated context, but even without Assumption 1, the update steps can still be applied. In fact, this is equivalent to an implementation of the so-called (online) expectation-maximization (EM) algorithm [10] for latent MDPs. Thus Algorithm 1 with Algorithm 3 essentially results in combining L-UCRL and the EM algorithm. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/061fafc7ea55dfaef0189346a9fd7b5a3ec4e57bde808779d52be306a6f3f98d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Learn PSR parameters up to precision o(δ)</td></tr><tr><td colspan=\"2\">Get clusters {Tm(*|s,a), Rm(-|s,a)}(s,a)∈S× A,m∈[M] with learned PSR parameters Build each MDP model by correctly assigning contexts to estimated model parameters Return Well-initialized model {Tm, Rm}m∈[M]</td></tr></table>",
+        "bbox": [
+            184,
+            109,
+            754,
+            176
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            204,
+            825,
+            261
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In terms of performance guarantees, using Algorithm 3 as a sub-routine for L-UCRL gives the same order of regret as in Theorem 3.3 as long as the true context can be almost reliably inferred: ",
+        "bbox": [
+            173,
+            267,
+            823,
+            296
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.4 Suppose Assumption 1 holds with $H > C \\cdot \\delta ^ { - 4 } \\log ^ { 2 } ( 1 / \\alpha ) \\log ( N / \\eta ) .$ for some absolute constants $C , \\delta > 0$ , and a parameter $\\alpha > 0$ such that $\\alpha \\ln ( 1 / \\alpha ) \\leq \\delta ^ { 2 } / ( 2 0 0 S )$ . If the initialization parameters satisfy equation (3) with some initialization error $\\epsilon _ { i n i t } \\leq \\delta ^ { 2 } / ( 2 0 0 \\ln ( 1 / \\alpha ) )$ , then with probability at least $1 - \\eta$ , the regret of Algorithm $^ { l }$ is bounded by: ",
+        "bbox": [
+            173,
+            310,
+            825,
+            368
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e5b2eb130e1aa5d59805805ad7fe08aac45e33a0b1e5c2d333635c72da59e6dc.jpg",
+        "text": "$$\nR e g r e t ( K ) \\lesssim H S \\sqrt { M A N } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            375,
+            594,
+            395
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The proof of Theorem 3.4 is given in Appendix D.3. The provable guarantees are only given for wellseparated LMDPs. Nevertheless, we empirically evaluate Algorithm 1 as a function of separations and initialization (see Figure 1). ",
+        "bbox": [
+            173,
+            410,
+            825,
+            453
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "An interesting consequence of Assumption 1 is that the length of episode can be logarithmic in the number of state and actions. With much longer time-horizons $H \\overset { \\cdot } { \\geq } \\Omega ( S ^ { 2 } A / \\delta ^ { 2 } )$ , [8, 18] assumed similar $\\delta$ -separation only for some $( s , a )$ pairs. While Assumption 1 requires a stronger assumption of $\\delta$ -separation for all state-actions, the requirement on the time-horizon can be significantly weaker with large state and action spaces. For a more discussion on the separation condition, we refer the readers to Appendix D.1. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            542
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 Learning LMDPs without Initialization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            558,
+            486,
+            574
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, we discuss efficient initialization with some additional assumptions. Clustering trajectories is the cornerstone of all our technical results, as this allows us to estimate the parameters of each hidden MDP and then apply the techniques of Section 3.2. The challenge is how to cluster when we have short trajectories, and no good initialization. ",
+        "bbox": [
+            174,
+            584,
+            825,
+            640
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The key is again in Assumption 1. In Section 3.3, we use a good initialization to obtain accurate estimates of the belief states. These can then be clustered, thanks to Assumption 1, allowing us to obtain the true label in hindsight. Without initialization, we cannot accurately compute the belief state, so this avenue is blocked. Instead, our key idea is to leverage a predictive state representation (PSR) of the POMDP dynamics, and then show that Assumption 1 allows us to cluster in this space. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            715
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 4 gives our approach. We first explain the high-level idea, and subsequently detail some of the more subtle points. Suppose we have PSR parameters allowing us to estimate ${ \\dot { \\mathbb { P } } } ( o | h | | \\mathbf { d o } a )$ , (the probabilities of any future observations $o = \\left( s ^ { \\prime } , r \\right)$ given a history $h$ and intervening action $a$ ) to within accuracy $o ( \\delta )$ . We then show that we can again apply Assumption 1, to (almost) perfectly cluster the MDPs by true context at the end of the episode. After we collect transition probabilities at all states near the end of episode, we can construct a full transition model for each MDP. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            805
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Learning the PSR to sufficient accuracy requires an additional assumption. We show that the following standard assumption on statistical sufficiency of histories and tests, is sufficient for our purposes (see also Section 2.2.1 and Appendix E.1): ",
+        "bbox": [
+            174,
+            811,
+            825,
+            854
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Assumption 2 (Sufficient Tests/Histories) Let $\\tau$ and $\\mathcal { H }$ be the set of all possible tests and histories of length $l = O ( 1 )$ respectively, with a given sampling policy $\\boldsymbol { \\mathscr { u } }$ (e.g., uniformly random policy) for histories H. $\\tau$ and $\\mathcal { H }$ satisfy Condition 1 and 2 respectively. ",
+        "bbox": [
+            176,
+            868,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/64010834130c9a47e244686a6fd340f184c387d34c86da044654ea3a36f48f2e.jpg",
+        "image_caption": [
+            "Figure 1: (a) L-UCRL when true contexts are revealed in hindsight and when we run with the EM algorithm. (b) $\\mathrm { E M } + \\mathrm { L }$ -UCRL (Algorithm 1) under different levels of separation and horizon length. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            88,
+            802,
+            207
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While the worst-case instance may require $l \\geq M$ to satisfy the full-rank conditions, we assume that the length of sufficient tests/histories is $l = O ( 1 )$ . In fact, $l = 1$ has been (implicitly) the common assumption in the literature on learning POMDPs [20, 5, 17, 25]. Empirically, we observe that the more MDPs differ, the more easily they satisfy Assumption 2. See Figure 2. At this point, we are not aware whether sample-efficient learning is possible with only Assumption 1. ",
+        "bbox": [
+            174,
+            256,
+            825,
+            325
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Though the main idea and key assumption are above, a few important details and technical assumptions remain to complete this story. The primary guarantee still required is that we have access to an exploration policy with sufficient mixing, to guarantee we can collect all required information to perform the PSR-based clustering. The following assumption ensures that additional ${ \\tilde { O } } ( M / \\alpha _ { 2 } )$ sample trajectories obtained with the exploration policy $\\pi$ can provide $M$ clusters of estimated one-step predictions $\\mathbb { P } _ { m } ( o | s , a )$ for every state $s$ and intervening action $a$ . ",
+        "bbox": [
+            174,
+            330,
+            825,
+            416
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Assumption 3 (Reachability of States) There exists a priori known exploration policy $\\pi$ such that, for all $m \\in [ M ]$ and $s \\in S$ , we have $\\mathbb { P } _ { m } ^ { \\pi } ( s _ { H - 1 } = s ) \\geq \\alpha _ { 2 }$ for some $\\alpha _ { 2 } > 0$ . ",
+        "bbox": [
+            173,
+            431,
+            823,
+            460
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A subtle point here is that we still have an ambiguity issue in the ordering of contexts (or labels) assigned in different states, which prevents us from recovering the full model for each context. We resolve this issues ambiguity assuming the MDP is connected, and give the full description of Algorithm 4 in Appendix E.2. We conclude this section with an (informal) end-to-end guarantee: ",
+        "bbox": [
+            173,
+            477,
+            825,
+            532
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.5 (Informal) Let Assumption 2 hold for an LMDP instance with a sampling policy $\\pi$ . Furthermore, assume the LMDP satisfies Assumptions 1 and 3. Then there exists an algorithm such that with probability at least $2 / 3$ , it returns a good initialization of LMDP parameters that satisfies (3) in time $p o l y ( A ^ { l } , S , H , M , \\sigma _ { h } ^ { - 1 } , \\sigma _ { \\tau } ^ { - 1 } , \\alpha _ { 2 } ^ { - 1 } , \\delta , \\epsilon _ { i n i t } ) .$ . ",
+        "bbox": [
+            173,
+            547,
+            825,
+            608
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.5 completes the pipeline for learning in latent MDPs: we initialize the parameters by the estimated PSR and clustering (see Appendix E) up to some accuracy, and then we run L-UCRL to refine the model and policy up to arbitrary accuracy (Algorithm 1). Full version of Theorem 3.5 can be found in Theorem E.3. ",
+        "bbox": [
+            173,
+            622,
+            825,
+            679
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            698,
+            312,
+            715
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate the proposed algorithm on synthetic data. Our first two experiments illustrate the performance of L-UCRL (Algorithm 1) for various levels of separation and quality of initialization. Then, we empirically study the performance of the PSR-Clustering algorithm for randomly generated LMDPs for different levels of separation and time-horizon. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            786
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1 The Value of True Contexts in Hindsight ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            801,
+            495,
+            818
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We first study the importance of receiving the true contexts in hindsight for the approach analyzed in this work, by comparing the performance of Algorithm 1 when instantiating it with Algorithm 2 or 3 as a sub-routine. We generate random instances of LMDPs of size $M = 7 , S = 1 5 , A = 3$ and set the time-horizon $H = 3 0$ . The reward distribution is set to be 0 for most state-action pairs. We compare when we give a true context to the algorithm (Algorithm 2) and when we infer a context with random initialization or good initialization (Algorithm 3). In the latter, it is equivalent to running the EM algorithm for the model estimation. For the planning algorithm, we use Q-MDP heuristic [32] which shows good empirical performance. We measure the model estimation error as $\\begin{array} { r } { \\begin{array} { r } { e r r o r : = \\operatorname* { m i n } _ { \\sigma \\in  { \\mathrm { P e r m } } _ { M } } \\sum _ { ( m , s , a ) } \\| \\big (  { \\mathbb { P } } _ { m } - \\hat {  { \\mathbb { P } } } _ { \\sigma ( m ) } \\big ) \\big ( s ^ { \\prime } , r | s , a \\big ) \\| _ { 1 } , } \\end{array} } \\end{array}$ where $ { \\mathrm { P e r m } } _ { M }$ denotes all length $M$ permutation sequences. The measured errors are averaged over 10 independent experiments. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/cff8930457abbaef9b5c1348ebdc9c59573e1c01c0d83f7a0d7ded9c2228619b.jpg",
+        "image_caption": [
+            "Figure 2: PSR learning and Clustering (Algorithm 4). Left: Convergence of belief state. Middle: $M ^ { t h }$ singular value of sufficient histories/tests matrix $P _ { \\mathcal { T } , \\mathcal { H } }$ . Right: Accuracy of the estimated model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            88,
+            789,
+            217
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            271,
+            825,
+            332
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The experimental results are given in Figure 1(a). When the true context is given at the end of episode (with Algorithm 2), L-UCRL converges to the optimal policy as our theory suggests. On the other hand, if the true context is not given (with Algorithm 3), the quality of initialization becomes crucial; when the model is poorly initialized, the estimated model converges to a local optimum which leads to a sub-optimal policy. When the model is well-initialized, L-UCRL performs as well as when true contexts are given in hindsight. ",
+        "bbox": [
+            173,
+            337,
+            825,
+            421
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2 Performance of L-UCRL with Good Initialization ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            439,
+            558,
+            454
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In our second experiment, we focus on the performance of L-UCRL (Algorithm 1) along with Algorithm 3 under different levels of separation $\\delta$ in Assumption 1) when approximately good model parameters are given. For various levels of $\\delta$ , we generate the parameters for transition probabilities randomly while keeping the distance between different MDPs to satisfy $\\delta \\leq \\| ( T _ { m _ { 1 } } -$ $\\bar { T } _ { m _ { 2 } } ) ( s ^ { \\prime } | s , a ) \\| _ { 1 } \\leq 2 \\delta$ for $m _ { 1 } \\neq m _ { 2 }$ . ",
+        "bbox": [
+            174,
+            465,
+            825,
+            536
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We show the error in the estimated model and average long-term rewards in Figure 1(b). When the separation is sufficient (larger $\\delta$ or $H$ ), the estimated model converges fast to the true parameters. When the separation gets small (smaller $\\delta$ or $H$ ), the convergence speed gets slower. This type of transition in the convergence speed of EM (the update of model parameters with Algorithm 3) is observed both in theory and practice when the overlap between mixture components gets larger (e.g., [29]). On the other hand, the policy steadily improves regardless of the level of separation. We conjecture that this is because the optimal policy would only need the model to be accurate in the total-variation distance, not in the actual estimated parameters. ",
+        "bbox": [
+            173,
+            541,
+            825,
+            652
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 Initialization with PSR and Clustering ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            670,
+            480,
+            685
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the third experiment, we evaluate the initialization algorithm (Algorithm 4) for randomly generated LMDP instances. Since PSR learning requires a (relatively) large number of short sample trajectories, we evaluate this step on smaller instances with $S = 7 , A = 2 , M = 3$ . The LMDP instances are generated similarly as in the second experiment with different levels of $\\delta$ and $H$ . The reward and initial distributions are set the same across all MDPs. To learn the parameters of PSR, we run $1 0 ^ { 6 }$ episodes with $H = 4$ . We assume histories and tests of length 1 are statistically sufficient with the uniformly random policy. In the clustering step, we run an additional $5 \\cdot 1 0 ^ { 3 }$ episodes to obtain longer trajectories of length $H = 2 0 , 4 0$ and 80. We report the experimental results in Figure 2. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            809
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We first observe how the level of separation $\\delta$ between MDPs impacts trajectory separation, i.e., belief state vs true label (left). Recall that this separation property is the key for clustering trajectories. We then examine the performance of Algorithm 4 (see full Algorithm 5) for various levels of separation. Empirically, it succeeds to get a good initialization of an LMDP model when we have sufficient separation. As the separation level decreases, the algorithm starts to fail (Right). There are two possible sources of the failure: (1) the belief state is far from the true context, and (2) the similarity between MDPs drops the $M ^ { t h }$ singular value of $P _ { \\mathcal { T } , \\mathcal { H } }$ (Middle). We can compensate for (1) if we have a longer time-horizon to infer true contexts, as in the leftmost graph. For (2), if the $M ^ { t h }$ singular value drops, we require more samples for the estimation of PSR parameters. In our experiments, as we decreased $\\delta$ we found that failure in the spectral learning step was the more significant of the two. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Future Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            151,
+            313,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "There are several interesting research avenues in continuation of this work. An interesting direction is to study RL algorithms for LMDPs with no underlying assumptions. Although our lower bound suggests such an algorithm necessarily suffers an exponential dependence in the number of contexts, if this number is small, such dependence might be acceptable. Specifically, we conjecture that general LMDPs can be learned with sample complexity of poly $\\left( \\dot { ( } H S A ) ^ { M } , \\epsilon ^ { - 1 } \\right)$ . For a special case when MDPs are deterministic, we show that the exponential dependence in $\\dot { M }$ is sufficient In Appendix G. The case for general LMDPs is an interesting open question. Furthermore, a needed empirical advancement is to design efficient ways to learn the set of sufficient histories/tests for learning predictive state representation of LMDPs. This can dramatically improve the performance of our algorithms when a sufficiently good initial model needs to be learned. ",
+        "bbox": [
+            174,
+            184,
+            825,
+            321
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgement ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            337,
+            302,
+            352
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The research was funded by NSF grant 2019844, and by the Army Research Office and was accomplished under Cooperative Agreement Number W911NF-19-2-0333. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the Army Research Office or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation herein. ",
+        "bbox": [
+            174,
+            363,
+            826,
+            445
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            465,
+            266,
+            481
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] A. Anandkumar, R. Ge, D. Hsu, S. M. Kakade, and M. Telgarsky. Tensor decompositions for learning latent variable models. Journal of Machine Learning Research, 15:2773–2832, 2014.   \n[2] A. Anandkumar, D. Hsu, and S. M. Kakade. A method of moments for mixture models and hidden markov models. In Conference on Learning Theory, pages 33–1, 2012.   \n[3] D. Arthur and S. Vassilvitskii. k-means $^ { + + }$ the advantages of careful seeding. In Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms, pages 1027–1035, 2007.   \n[4] M. G. Azar, I. Osband, and R. Munos. Minimax regret bounds for reinforcement learning. arXiv preprint arXiv:1703.05449, 2017.   \n[5] K. Azizzadenesheli, A. Lazaric, and A. Anandkumar. Reinforcement learning of POMDPs using spectral methods. In Conference on Learning Theory, pages 193–256, 2016.   \n[6] B. Boots and G. J. Gordon. An online spectral learning algorithm for partially observable nonlinear dynamical systems. In Twenty-Fifth AAAI Conference on Artificial Intelligence, 2011.   \n[7] B. Boots, S. M. Siddiqi, and G. J. Gordon. Closing the learning-planning loop with predictive state representations. The International Journal of Robotics Research, 30(7):954–966, 2011.   \n[8] E. Brunskill and L. Li. Sample complexity of multi-task reinforcement learning. In Uncertainty in Artificial Intelligence, page 122. Citeseer, 2013.   \n[9] P. Buchholz and D. Scheftelowitsch. Computation of weighted sums of rewards for concurrent MDPs. Mathematical Methods of Operations Research, 89(1):1–42, 2019.   \n[10] O. Cappé and E. Moulines. On-line expectation–maximization algorithm for latent data models. Journal of the Royal Statistical Society: Series B (Statistical Methodology), 71(3):593–613, 2009.   \n[11] I. Chadès, J. Carwardine, T. Martin, S. Nicol, R. Sabbadin, and O. Buffet. Momdps: a solution for modelling adaptive management problems. In Twenty-Sixth AAAI Conference on Artificial Intelligence (AAAI-12), 2012.   \n[12] C. Dann, N. Jiang, A. Krishnamurthy, A. Agarwal, J. Langford, and R. E. Schapire. On oracleefficient PAC RL with rich observations. In Advances in neural information processing systems, pages 1422–1432, 2018.   \n[13] S. Du, A. Krishnamurthy, N. Jiang, A. Agarwal, M. Dudik, and J. Langford. Provably efficient rl with rich observations via latent state decoding. In International Conference on Machine Learning, pages 1665–1674, 2019.   \n[14] A. Garivier, P. Ménard, and G. Stoltz. Explore first, exploit next: The true shape of regret in bandit problems. Mathematics of Operations Research, 44(2):377–399, 2019.   \n[15] C. Gentile, S. Li, P. Kar, A. Karatzoglou, G. Zappella, and E. Etrue. On context-dependent clustering of bandits. In International Conference on Machine Learning, pages 1253–1262. PMLR, 2017.   \n[16] C. Gentile, S. Li, and G. Zappella. Online clustering of bandits. In International Conference on Machine Learning, pages 757–765, 2014.   \n[17] Z. D. Guo, S. Doroudi, and E. Brunskill. A PAC RL algorithm for episodic POMDPs. In Artificial Intelligence and Statistics, pages 510–518, 2016.   \n[18] A. Hallak, D. Di Castro, and S. Mannor. Contextual markov decision processes. arXiv preprint arXiv:1502.02259, 2015.   \n[19] A. Hefny, C. Downey, and G. J. Gordon. Supervised learning for dynamical system learning. In Advances in neural information processing systems, pages 1963–1971, 2015.   \n[20] D. Hsu, S. M. Kakade, and T. Zhang. A spectral algorithm for learning hidden markov models. Journal of Computer and System Sciences, 78(5):1460–1480, 2012.   \n[21] T. Jaakkola, S. P. Singh, and M. I. Jordan. Reinforcement learning algorithm for partially observable markov decision problems. In Advances in neural information processing systems, pages 345–352, 1995.   \n[22] T. Jaksch, R. Ortner, and P. Auer. Near-optimal regret bounds for reinforcement learning. Journal of Machine Learning Research, 11:1563–1600, 2010.   \n[23] N. Jiang, A. Krishnamurthy, A. Agarwal, J. Langford, and R. E. Schapire. Contextual decision processes with low bellman rank are PAC-learnable. In International Conference on Machine Learning, pages 1704–1713. PMLR, 2017.   \n[24] N. Jiang, A. Kulesza, and S. Singh. Improving predictive state representations via gradient descent. In Thirtieth AAAI Conference on Artificial Intelligence, 2016.   \n[25] C. Jin, S. M. Kakade, A. Krishnamurthy, and Q. Liu. Sample-efficient reinforcement learning of undercomplete POMDPs. arXiv preprint arXiv:2006.12484, 2020.   \n[26] A. Krishnamurthy, A. Agarwal, and J. Langford. PAC reinforcement learning with rich observations. In Advances in Neural Information Processing Systems, pages 1840–1848, 2016.   \n[27] J. Kwon and C. Caramanis. The EM algorithm gives sample-optimality for learning mixtures of well-separated gaussians. In Conference on Learning Theory, pages 2425–2487, 2020.   \n[28] J. Kwon and C. Caramanis. EM converges for a mixture of many linear regressions. In International Conference on Artificial Intelligence and Statistics, pages 1727–1736, 2020.   \n[29] J. Kwon, N. Ho, and C. Caramanis. On the minimax optimality of the EM algorithm for learning two-component mixed linear regression. arXiv preprint arXiv:2006.02601, 2020.   \n[30] Y. Li, B. Yin, and H. Xi. Finding optimal memoryless policies of POMDPs under the expected average reward criterion. European Journal of Operational Research, 211(3):556–567, 2011.   \n[31] M. L. Littman. Memoryless policies: Theoretical limitations and practical results. In From Animals to Animats 3: Proceedings of the third international conference on simulation of adaptive behavior, volume 3, page 238. Cambridge, MA, 1994.   \n[32] M. L. Littman, A. R. Cassandra, and L. P. Kaelbling. Learning policies for partially observable environments: Scaling up. In Machine Learning Proceedings 1995, pages 362–370. Elsevier, 1995.   \n[33] M. L. Littman and R. S. Sutton. Predictive representations of state. In Advances in neural information processing systems, pages 1555–1561, 2002.   \n[34] Y. Liu, Z. Guo, and E. Brunskill. PAC continuous state online multitask reinforcement learning with identification. In Proceedings of the 2016 International Conference on Autonomous Agents & Multiagent Systems, pages 438–446, 2016.   \n[35] O.-A. Maillard and S. Mannor. Latent bandits. In International Conference on Machine Learning, pages 136–144, 2014.   \n[36] A. Modi, N. Jiang, S. Singh, and A. Tewari. Markov decision processes with continuous side information. In Algorithmic Learning Theory, pages 597–618, 2018.   \n[37] A. Y. Ng and M. Jordan. PEGASUS: a policy search method for large MDPs and POMDPs. In Proceedings of the Sixteenth conference on Uncertainty in artificial intelligence, pages 406–415, 2000.   \n[38] C. H. Papadimitriou and J. N. Tsitsiklis. The complexity of Markov decision processes. Mathematics of operations research, 12(3):441–450, 1987.   \n[39] J. Pineau, G. Gordon, and S. Thrun. Anytime point-based approximations for large POMDPs. Journal of Artificial Intelligence Research, 27:335–380, 2006.   \n[40] S. Ross, M. Izadi, M. Mercer, and D. Buckeridge. Sensitivity analysis of POMDP value functions. In 2009 International Conference on Machine Learning and Applications, pages 317–323. IEEE, 2009.   \n[41] S. Singh, M. R. James, and M. R. Rudary. Predictive state representations: a new theory for modeling dynamical systems. In Proceedings of the 20th conference on Uncertainty in artificial intelligence, pages 512–519, 2004.   \n[42] R. D. Smallwood and E. J. Sondik. The optimal control of partially observable markov processes over a finite horizon. Operations research, 21(5):1071–1088, 1973.   \n[43] T. Smith and R. Simmons. Heuristic search value iteration for POMDPs. In Proceedings of the 20th conference on Uncertainty in artificial intelligence, pages 520–527, 2004.   \n[44] M. T. Spaan and N. Vlassis. Perseus: Randomized point-based value iteration for POMDPs. Journal of artificial intelligence research, 24:195–220, 2005.   \n[45] L. N. Steimle, D. L. Kaufman, and B. T. Denton. Multi-model markov decision processes. Optimization Online URL http://www. optimization-online. org/DB_FILE/2018/01/6434. pdf, 2018.   \n[46] G. W. Stewart. Matrix perturbation theory. 1990.   \n[47] M. E. Taylor and P. Stone. Transfer learning for reinforcement learning domains: A survey. Journal of Machine Learning Research, 10(7), 2009.   \n[48] R. Vershynin. Introduction to the non-asymptotic analysis of random matrices. arXiv preprint arXiv:1011.3027, 2010. ",
+        "bbox": [
+            179,
+            488,
+            828,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            71,
+            828,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            830,
+            797
+        ],
+        "page_idx": 11
+    }
+]

parse/train/LOHyqjfyra/LOHyqjfyra.md

@@ -0,0 +1,182 @@
+# On Interaction Between Augmentations and Corruptions in Natural Corruption Robustness
+
+Eric Mintun∗ Facebook AI Research mintun@fb.com
+
+Alexander Kirillov Facebook AI Research akirillov@fb.com
+
+Saining Xie Facebook AI Research s9xie@fb.com
+
+# Abstract
+
+Invariance to a broad array of image corruptions, such as warping, noise, or color shifts, is an important aspect of building robust models in computer vision. Recently, several new data augmentations have been proposed that significantly improve performance on ImageNet-C, a benchmark of such corruptions. However, there is still a lack of basic understanding on the relationship between data augmentations and test-time corruptions. To this end, we develop a feature space for image transforms, and then use a new measure in this space between augmentations and corruptions called the Minimal Sample Distance to demonstrate a strong correlation between similarity and performance. We then investigate recent data augmentations and observe a significant degradation in corruption robustness when the test-time corruptions are sampled to be perceptually dissimilar from ImageNet-C in this feature space. Our results suggest that test error can be improved by training on perceptually similar augmentations, and data augmentations may not generalize well beyond the existing benchmark. We hope our results and tools will allow for more robust progress towards improving robustness to image corruptions. We provide code at https://github.com/facebookresearch/augmentation-corruption.
+
+# 1 Introduction
+
+Robustness to distribution shift, i.e. when the train and test distributions differ, is an important feature of practical machine learning models. Among many forms of distribution shift, one particularly relevant category for computer vision are image corruptions. For example, test data may come from sources that differ from the training set in terms of lighting, camera quality, or other features. Postprocessing transforms, such as photo touch-up, image filters, or compression effects are commonplace in real-world data. Models developed using clean, undistorted inputs typically perform dramatically worse when confronted with these sorts of image corruptions [8, 13]. The subject of corruption robustness has a long history in computer vision [1, 6, 28] and recently has been studied actively with the release of benchmark datasets such as ImageNet-C [13].
+
+One particular property of image corruptions is that they are low-level distortions in nature. Corruptions are transformations of an image that affect structural information such as colors, textures, or geometry [5] and are typically free of high-level semantics. Therefore, it is natural to expect that data augmentation techniques, which expand the training set with random low-level transformations, can help learn robust models. Indeed, data augmentation has become a central technique in several recent methods [14, 20, 25] that achieve large improvements on ImageNet-C and related benchmarks.
+
+One caveat for data augmentation based approaches is the test corruptions are expected to be unknown at training time. If the corruptions are known, they may simply be applied to the training set as data augmentations to trivially adapt to the test distribution. Instead, an ideal robust model needs to be robust to any valid corruption, including ones unseen in any previous benchmark. Of course, in practice the robustness of a model can only be evaluated approximately by measuring its corruption error on a representative corruption benchmark. To avoid trivial adaptation to the benchmark, recent works manually exclude test corruptions from the training augmentations. However, with a toy experiment presented in Figure 1, we argue that this strategy alone might not be enough and that visually similar augmentation outputs and test corruptions can lead to significant benchmark improvements even if the exact corruption transformations are excluded.
+
+![](images/fe090e63eeb377f94bef1f6849361fcdef3729355d87e25cbd42014e40b03afb.jpg)  
+Figure 1: A toy experiment. We train multiple models on CIFAR-10 [17] using different augmentation schemes. Each scheme is based on a single basic image transformation type and enhanced by overlaying random instantiations of the transformation for each input image following Hendrycks et al. [14]. We compare these models on the CIFAR-10 test set corrupted by the motion blur, a corruption used in the ImageNet-C corruption benchmark [13]. None of the augmentation schemes contains motion blur; however, the models trained with geometric-based augmentations significantly outperform the baseline model trained on the clean images while color-based augmentations show no gains. We note the geometric augmentations can produce a result visually similar to a blur by overlaying copies of shifted images3.
+
+This observation raises two important questions. One, how exactly does the similarity between train time augmentations and corruptions of the test set affect the error? And two, if the gains are due to the similarity, they may not translate into better robustness to other possible corruptions, so how well will data augmentations generalize beyond a given benchmark? In this work, we take a step towards answering these questions, with the goal of better understanding the relationship between data augmentation and test-time corruptions. Using a feature space on image transforms and a new measure called Minimal Sample Distance (MSD) on this space, we are able to quantify the distance between augmentation schemes and classes of corruption transformation. With our approach, we empirically show an intuitive yet surprisingly overlooked finding:
+
+Augmentation-corruption perceptual similarity is a strong predictor of corruption error.
+
+Based on this finding, we perform additional experiments to show that data augmentation aids corruption robustness by increasing perceptual similarity between a (possibly small) fraction of the training data and the test set. To further support our claims, we introduce a set of new corruptions, called CIFAR/ImageNet-C, to test the degree to which common data augmentation methods generalize from the original CIFAR/ImageNet-C. To choose these corruptions, we expand the set of natural corruptions and sample new corruptions that are far away from CIFAR/ImageNet-C in our feature space for measuring perceptual similarity. We then demonstrate that augmentation schemes designed specifically to improve robustness show significantly degraded performance on CIFAR/ImageNet-C. Some augmentation schemes still show some improvement over baseline, which suggests meaningful progress towards general corruption robustness is being made, but different augmentation schemes exhibit different degrees of generalization capability. As an implication, caution is needed for fair robustness evaluations when additional data augmentation is introduced.
+
+These results suggest a major challenge that is often overlooked in the study of corruption robustness: generalization is often poor. Since perceptual similarity can predict performance, for any fixed finite set of test corruptions, improvements on that set may generalize poorly to dissimilar corruptions. We hope that these results, tools, and benchmarks will help researchers better understand why a given augmentation scheme has good corruption error and whether it should be expected to generalize to dissimilar corruptions. On the positive side, our experiments show that generalization does emerge among perceptually similar transforms, and that only a small fraction of sampled augmentations need to be similar to a given corruption. Section 6 discusses these points in more depth.
+
+# 2 Related Work
+
+Corruption robustness benchmarks and analysis. ImageNet-C [13] is a corruption dataset often used as a benchmark in robustness studies. Other corruption datasets [15, 27] collect corrupted images from real world sources and thus have a mixture of semantic distribution shifts and perceptual transforms. Corruption robustness differs from adversarial robustness [31], which seeks invariance to small, worst case distortions. One notable difference is that improving corruption robustness often slightly improves regular test error, instead of harming it. Yin et al. [38] analyzes corruption robustness in the context of transforms’ frequency spectra; this can also influence corruption error independently from perceptual similarity. Here we study the relationship between augmentations and corruptions more generically, and explore the relationship between perceptual similarity and generalization to new corruptions. Dao et al. [3] and Wu et al. [36] study the theory of data augmentation for regular test error. Hendrycks et al. [15] and Taori et al. [33] study how the performance on synthetic corruption transforms generalizes to performance on corruption datasets collected from the real world. Here we do not address this issue directly but touch upon it in the discussion.
+
+Improving corruption robustness. Data augmentations designed to improve robustness include AugMix [14], which composites common image transforms, Patch Gaussian [20], which applies Gaussian noise in square patches, and ANT [25], which augments with an adversarially learned noise distribution. AutoAugment [2] learns augmentation policies that optimize clean error but has since been shown to improve corruption error [38]. Mixup [40] can improve robustness [18], but its label augmentation complicates the dependence on image augmentation. Stylized-ImageNet [9], which applies style transfer to input images, can also improve robustness. DeepAugment [15], which applies augmentations to a deep representation of an image, can also give large improvements in robustness. Noisy Student [37] and Assemble-ResNet [18] combine data augmentation with new models and training procedures and greatly enhance corruption robustness. In addition to training-time methods, there are approaches that adapt to unseen corruptions at test time, e.g. using self-supervised tasks [30], entropy minimization [35], or with a focus on privacy and data transmission efficiency [19]. While we do not directly address these approaches here, our methods potentially provide tools that could be used to measure shifting distributions in an online regime.
+
+# 3 Perceptual similarity for augmentations and corruptions
+
+First, we study the importance of similarity between augmentations and corruptions for improving performance on those corruptions. To do so, we need a means to compare augmentations and corruptions. Both types of transforms are perceptual in nature, meaning they affect low-level image structure while leaving high-level semantic information intact, so we expect a good distance to be a measure of perceptual similarity. Then, we need to find the appropriate measure of distance between the augmentation and corruption distributions. We will argue below that distributional equivalence is not appropriate in the context of corruption robustness, and instead introduce the minimal sample distance, a simple measure that does capture a relevant sense of distribution distance.
+
+Measuring similarity between perceptual transforms. We define a perceptual transform as a transform that acts on low-level image structure but not high-level semantic information. As such, we expect two transforms should be similar if their actions on this low-level structure are similar, independent of algorithmic or per-pixel differences between them. A closely related, well-studied problem is the perceptual similarity between images. A common approach is to train a neural network on a classification task and use intermediate layers as a feature space for measuring distances [42]. We adapt this idea to obtain a feature space for measuring distances between perceptual transforms.
+
+We start with a feature extractor for images, which we call $\hat { f } ( x )$ . To train the model from which we will extract features, we assume access to a dataset $\mathbb { D }$ of image label pairs $( x , y )$ associated with a classification task. The model should be trained using only default data augmentation for the task in question so that the feature extractor is independent of the transforms we will use it to study. In order to obtain a very simple measure, we use just the last hidden layer of the network as a feature space.
+
+![](images/8506044a99d204381d92eb25f104590e102c5d67dd35b62b1721d2730c035e11.jpg)  
+Figure 2: (a) Schematic comparison of MMD to MSD. MMD measures the distance between distribution centers and is only small if the augmentation overlaps with a corruption. MSD measures to the nearest sampled point in the set of samples (marked by a star) and is small even for broad distributions that overlap with multiple corruptions. (b) We test on images corrupted with impulse noise, and train on images augmented with a mixture of impulse noise and motion blur. As the mixing fraction of impulse noise decreases, MMD between the augmentation and corruption grows linearly while MSD and error stay low until nearly $0 \%$ mixing fraction.
+
+A perceptual transform $t ( x )$ may be encoded by applying it to all images in $\mathbb { D }$ , encoding the transformed images, and averaging the features over these images. For efficiency, we find it sufficient to average over only a randomly sampled subset of images $\mathbb { D } _ { S }$ in $\mathbb { D }$ . In Section 4.1 we discuss the size of $\mathbb { D } _ { S }$ . The random choice of images is a property of the feature extractor, and so remains fixed when encoding multiple transforms. This reduces variance when computing distances between two transforms. The transform feature extractor is given by $f ( t ) = \mathbb { E } _ { x \in \mathbb { D } _ { S } } [ \hat { f } ( t ( x ) ) - \hat { f } ( x ) ]$ . The perceptual similarity between an augmentation and a corruption can be taken as the $L _ { 2 }$ distance on this feature space $f$ .
+
+Minimal sample distance. We now seek to compare the distribution of an augmentation scheme $p _ { a }$ to a distribution of a corruption benchmark $p _ { c }$ . If the goal was to optimize error on a known corruption distribution, exact equivalence of distributions is the correct measure to minimize. But since the goal is robustness to general, unknown corruption distributions, a good augmentation scheme should be equivalent to no single corruption distribution.
+
+To illustrate this behavior, consider a toy problem where we have access to the corruption transforms at training time. A very rough, necessary-but-insufficient measure of distributional similarity is $d _ { \mathrm { M M D } } ( p _ { a } , p _ { c } ) = | | \mathbb { E } _ { a \sim p _ { a } } [ f ( a ) ] - \mathbb { E } _ { c \sim p _ { c } } [ f ( c ) ] | |$ . This is the maximal mean discrepancy on a fixed, finite feature space, so for brevity we will refer to it as MMD. We still employ the featurization $f ( t )$ , since we are comparing transforms and not images, unlike in typical domain adaptation. Consider two corruption distributions, here impulse noise and motion blur, and an augmentation scheme that is a mixture of the two corruption distributions. Figure 2b shows MMD between the augmentation and impulse noise corruption scales linearly with mixing fraction, but error on impulse noise remains low until the mixing fraction is almost $0 \%$ impulse noise. This implies distributional similarity is a poor predictor of corruption error. Indeed, low $d _ { \mathrm { M M D } }$ with any one corruption distribution suggests the augmentation overlaps it significantly, so the augmentation is unlikely to aid dissimilar corruptions.
+
+Our expectation for the behavior of the error in Figure 2b is that networks can often successfully memorize rare examples seen during training, so that only a very small fraction of sampled images need impulse noise augmentations to perform well on impulse noise corruptions. An appropriate distance should then measure how close augmentation samples can come to the corruption distribution, even if the density of those samples is low. We thus propose a very simple measure called minimal sample distance (MSD), which is just the perceptual similarity between an average corruption and the closest augmentation from a finite set of samples A $\sim p _ { a }$ :
+
+$$
+d _ { \mathrm { M S D } } ( p _ { a } , p _ { c } ) = \operatorname* { m i n } _ { a \in \mathbb { A } \sim p _ { a } } \left| | f ( a ) - \mathbb { E } _ { c \sim p _ { c } } [ f ( c ) ] | \right| .
+$$
+
+![](images/33d3208269f30287d53a25941c7a175d6582d601676ec3c3f6f7abd703715409.jpg)  
+18 7.012 6.0Figure 3: Example relationships between MSD and corruption error. $\rho$ is the Spearman rank 16 200.2 0.4 0.6 0.8 0.4 0.8 1.2 1.612 0.10 0.14 0.18 0.22correlation. MSD correlates well with error across all four categories of corruption in CIFAR-10-C. 14 16 Minimal Sample DistanceFor completeness, we also show brightness, a negative example where correlation is poor.
+
+0.2 0.4 0.6 0.8 0.4 0.8 1.2 1.6 0.10 0.14 0.18 0.22A schematic comparison of MMD and MSD is shown in Figure 2a. While both MMD and MSD Minimal Sample Distanceare small for an augmentation scheme that is distributionally similar to a corruption distribution, only MSD remains small for a broad distribution that occasionally produces samples near multiple corruption distributions. Figure 2b shows MSD, like test error, is small for most mixing fractions in the toy problem described above. Note the measure’s need to accommodate robustness to general, unknown corruption distributions has led it to be asymmetric, so it differs from more formal distance metrics that may be used to predict generalization error, such as the Wasserstein distance [43].
+
+# 4 Perceptual similarity is predictive of corruption error
+
+We are now equipped to measure how important this augmentation-corruption similarity is for corruption error. For a large number of augmentation schemes, we will measure both the MSD to a corruption distribution and the corruption error of a model trained with that scheme. We will find a correlation between MSD and corruption error, which provides evidence that networks generalize across perceptually similar transforms. Then, we will calculate MSD for augmentation schemes in the literature that have been shown to improve error on corruption benchmarks. We will find a correlation between MSD and error here as well, suggesting their success is in part explained by their perceptual similarity to the benchmark. This implies there may be a risk of poor generalization to different benchmarks, since we would not expect this improvement to transfer to a dissimilar corruption.
+
+# 4.1 Experimental setup
+
+Corruptions. We use CIFAR-10-C [13], which is a common benchmark used for studying corruption robustness. It consists of 15 corruptions, each further split into five different severities of transformation, applied to the CIFAR-10 test set. The 15 corruptions fall into four categories: per-pixel noise, blurring, synthetic weather effects, and digital transforms. We treat each corruption at each severity as a separate distribution for the sake of calculating MSD and error; however, for simplicity we average errors and distances over severity to present a single result per corruption.
+
+Space of augmentation schemes. To build each sampled augmentation transform, we will composite a set of base augmentations. For base augmentations, we consider the nine common image transforms used in Hendrycks et al. [14]. There are five geometric transforms and four color transforms. By taking all subsets of these base augmentations, we obtain $2 ^ { 9 } = 5 1 2$ unique augmentation schemes, collectively called the augmentation powerset. Also following Hendrycks et al. [14], we composite transforms in two ways: by applying one after another, or by applying them to copies of the image and then linearly superimposing the results. Examples of both augmentations and corruptions are provided in Appendix F.
+
+Computing similarity and corruption error. A WideResNet-40-2 [39] model is pre-trained on CIFAR-10 using default augmentation and training parameters from Hendrycks et al. [14]. WideResNet is a common baseline model used when studying data augmentation on CIFAR-10 [2, 14, 40]. Its last hidden layer is used as the feature space. For MSD, we average over 100 images, 100 corruptions, and minimize over $1 0 0 \mathrm { k }$ augmentations. With this number of corruptions and images, we find that the average standard deviation in distance between an augmentation and the averaged corruptions is roughly five percent of the mean, which is smaller than the typical feature in our results found below, given in Figure 3. We also find that using VGG [29] instead of WideResNet for the feature extractor
+
+![](images/754ebcaed957914f40b406c3c5651bb1eefe20c091f79274177833423931217a.jpg)  
+25 w/ solarize w/ x-translationFigure 4: Example relationships between base augmentations and corruptions. Including solarize 10reduces MSD on the perceptually similar impulse noise corruption. Including $x$ translation reduces 20MSD on the perceptually similar motion blur corruption. MSD is not decreased for dissimilar Minimum Sample D    augmentation-corruption pairs.
+
+10gives similar results. Details for these calculations are in Appendix C. Images for calculating MSD are from the training set and do not have default training augmentation. A WideResNet-40-2 with the 0.2 0.6 1.0 1.4 0.2 0.6 1.0 1.4same training parameters is used for corruption error evaluation.
+
+# 4.2 Analysis
+
+MSD correlates with corruption error. First, we establish the correlation between MSD and corruption error on the augmentation powerset. MSD shows strong correlation with corruption error across corruptions types in all four categories of CIFAR-10-C, and for a large majority of CIFAR-10-C corruptions in general: 12 of 15 have Spearman rank correlation greater than 0.6. Figure 3 shows the relationship between distance and corruption error on six example corruptions, including one negative example for which correlation is low. A complete set of plots is below in Figure 5. This corruption, brightness, may give poor results because it is a single low-level image statistic that can vary significantly from image to image, and thus may not be well represented by our feature extractor. Appendix B has a few supplemental experiments. First, we we confirm MMD correlates poorly with corruption error, as expected. In particular, we expect broad augmentation schemes produce samples similar to a larger set of corruptions, leading to both lower MSD and lower corruption error but higher MMD. Second, we repeat our experiment but do not train on the augmentations, instead only adapting the batch norm statistics of a pre-trained model to them. We still find a strong correlation, suggesting our methods are compatible with the results of Schneider et al. [26], which shows such an adaptation of the batch norm statistics to a corruption can improve corruption error.
+
+An example of perceptual similarity. Here we illustrate the perceptual nature of the similarity measure, using an example with two base augmentations and two corruptions. The augmentation solarize and the corruption impulse noise both insert bright pixels into the image, though in different ways. Linear superpositions of the augmentation $x$ translation are visually similar to a blur, such as the corruption motion blur. Figure 4 shows MSD vs error where augmentation schemes that include solarize and $x$ translation are colored. It is clear that including an augmentation greatly decreases MSD to its perceptually similar corruption, while having little effect on MSD to its perceptually dissimilar corruption.
+
+MSD and corruption error in real augmentation methods. The augmentation powerset may be used as a baseline for comparing real data augmentation schemes. Figure 5 shows MSD-error correlations for Patch Gaussian [20], AutoAugment [2], and Augmix [14], along with the cloud of augmentation powerset points for all 15 CIFAR-10-C corruptions. The real augmentation schemes follow the same general trend that lower error predicts lower MSD. A few intuitive correlations are also captured in Figure 5. Patch Gaussian has low MSD to noise corruptions. AutoAugment, which contains contrast and Gaussian blurring augmentations in its sub-policies, has low MSD with contrast and defocus blur. A negative example is fog, on which MSD to AutoAugment is not predictive of corruption error.
+
+This correlation suggests generalization may be poor beyond an existing benchmark, since an augmentation scheme may be perceptually similar to one benchmark but not another. For augmentations and corruptions that are explicitly the same, such as contrast in AutoAugment and ImageNet-C, this is typically accounted for by removing such transforms from the augmentation scheme when testing corruption robustness4. But in addition to these explicit similarities, Figure 5 shows quantitatively that perceptual similarity between non-identical augmentations and corruptions is also strongly predictive of corruption error. This includes possibly unexpected similarities, such as between Patch Gaussian and glass blur, which introduces random pixel-level permutations as noise. This suggests that perceptually similar augmentations and corruptions should be treated with the same care as identical transforms. In particular, tools such as MSD help us determine why an augmentation scheme improves corruption error, so we can better understand if new methods will generalize beyond their tested benchmarks. Next we test this generalization by finding corruptions dissimilar to ImageNet-C.
+
+![](images/d4816a08ab544b8902c76e2ed306197c37edf23422e76c702e28ac2d93da066d.jpg)  
+Figure 5: Correlations for augmentation schemes from the literature. Patch Gaussian is similar to noise, while AutoAugment is similar to contrast and blur, as expected from their formulation. Glass blur acts more like a noise corruption than a blur for these augmentation schemes, likely because it randomly permutes pixels. As a negative example, MSD does not correlate well with error for AutoAugment on fog. \*AugMix here refers to just the augmentation distribution in Hendrycks et al. [14], not the proposed Jensen-Shannon divergence loss.
+
+# 5 ImageNet-C: benchmarking with dissimilar corruptions
+
+We now introduce a set of corruptions, called ImageNet-C, that are perceptually dissimilar to ImageNet-C in our transform feature space, and we will show that several augmentation schemes have degraded performance on the new dataset. We emphasize that the dataset selection method uses only default data augmentation and was fixed before we looked at the results for different augmentations, so we are not adversarially selecting against the tested augmentation schemes.
+
+Dataset construction. Here we present an overview of the dataset construction method. We build 30 new corruptions in 10 severities, from which the 10 most dissimilar corruptions will be chosen. We adapt common filters and noise distributions available online [10, 16] to produce human interpretable images. The transforms include warps, blurs, color distortions, noise additions, and obscuring effects. Examples of the new corruptions and exact details of the construction method are provided in Appendices D and F.
+
+![](images/47e802717f039011da8d3fa76d9b4cc61d83551f82c9eb8df720c25f4de6d572.jpg)  
+Brown Noise Checkerboard Cocentric Sine Waves Perlin Noise Single Frequency NoiseImageNet-C CorruptionsFigure 6: Example CIFAR-10-C and ImageNet-C corruptions. While still human interpretable, new corruptions are sampled to be dissimilar from CIFAR-10/ImageNet-C. Base images $^ ©$ Sehee Park and Chenxu Han.
+
+Blue Noise Sample Caustic Refraction Inverse Sparkle Plasma Noise SparklesTo assure that the new dataset is no harder than ImageNet-C, we restrict the average corruption error of the new dataset to be similar to that of ImageNet-C for default augmentation. We then generate many potential datasets and measure the average shift in distance to ImageNet-C that each corruption contributes. Note that while MSD is a measure between augmentations and corruptions, here we are comparing corruptions to other corruptions and thus use MMD in our transform feature space. ImageNet-C then consists of the 10 corruptions types with the largest average shift in distance. Like ImageNet-C, each has five different severities, with severities chosen so that the average error matches ImageNet-C for default augmentation. Example transforms from ImageNet-C and CIFAR-10-C are shown in Figure 6. This procedure in our feature space produces corruptions intuitively dissimilar from ImageNet-C and CIFAR-10-C.
+
+Results. We test AutoAugment [2], Patch Gaussian [20], AugMix [14], $\mathbf { A N T } ^ { 3 \mathrm { x } 3 }$ [25], StylizedImageNet [9], and DeepAugment [15] on our new datasets and show results in Table 1. CIFAR-10 models are WideResNet-40-2 with training parameters from Hendrycks et al. [14]. ImageNet [4] models are ResNet-50 [12] with training parameters from Goyal et al. [11]. Stylized-ImageNet is trained jointly with ImageNet for half the epochs and starts from a model pre-trained on ImageNet, following Geirhos et al. [9]. Models use default data augmentation as well as the augmentation being tested, except ImageNet color jittering is not used. All corruptions are applied in-memory instead of loaded from a compressed file; this can affect results especially on high frequency corruptions.
+
+Since Section 4 suggests several augmentation schemes are perceptually similar to ImageNet-C corruptions, we might expect these methods to have worse error on the new corruptions. Indeed, every augmentation scheme performs worse. Different augmentation schemes also degrade by significantly different amounts, from $+ 0 . 7 \%$ for AutoAugment to $+ 7 . 3 \%$ for PatchGaussian, which changes their ranking by corruption error and leads to inconsistency of generalization. In Table 2, we compare performance on several robust models[7, 21, 22, 32, 34, 37, 41] that are not primarily augmentationbased and see no similar pattern of degradation, further suggesting that augmentation-corruption dissimilarity is the cause of the higher error.
+
+Errors of individual corruptions in ImageNet-C are also revealing. For all augmentation schemes, there is significant improvement on blue sample noise5 but little improvement on sparkles or inverse sparkles. Only AutoAugment does well on checkerboard, perhaps because only AutoAugment’s geometric transforms produce empty space, similar to checkerboard’s occluded regions. These examples suggest a slightly different benchmark could yield significantly different results. Indeed, for a hypothetical benchmark that excluded blue sample noise and checkerboard, AutoAugment and Patch Gaussian have $5 7 . 3 \%$ and $5 7 . 2 \%$ error respectively, little better than baseline of $5 7 . 4 \%$ . AugMix fairs only a little better with $5 4 . 3 \%$ error. Even DeepAugment+AugMix, which is in general a strong augmentation scheme, shows a big discrepancy in performance across different corruptions, improving single frequency noise by $31 \%$ , but inverse sparkles by only $2 . 3 \%$ . Generalization to dissimilar corruptions is thus both inconsistent and typically quite poor. Single benchmarks and aggregate corruption scores are likely not enough for careful evaluation of robustness to unknown corruptions, and it is important to study why proposed augmentations succeed to better understand how well they might generalize.
+
+Table 1: Test error for several data augmentation methods on CIFAR-10-C and ImageNet-10- $\overline { { C } }$ , for which every method performs worse than on ImageNet-C or CIFAR-10-C. The increase in error differs significantly between different augmentation methods. Descriptions of the abbreviations and standard deviations for individual corruptions are in Appendix D. ‘Baseline’ refers to default augmentation only. Averages are over five runs for ImageNet and ten for CIFAR-10. \*ANT, DeepAugment(DA) and DeepAugment+AugMix $( \mathrm { D A } { + } \mathrm { A M } )$ use the pre-trained model provided with the associated papers and have different training parameters.   
+
+<table><tr><td rowspan="2">Aug</td><td rowspan="2">IN-C Err</td><td colspan="2">IN-C</td><td colspan="10">ImageNet-C Corruptions</td></tr><tr><td>Err</td><td>△IN-C</td><td>BSmpl Plsm</td><td></td><td>Ckbd</td><td>CSin</td><td>SFrq</td><td>Brwn</td><td>Prln</td><td>Sprk</td><td>ISprk</td><td>Rfrac</td></tr><tr><td>Baseline</td><td></td><td>58.1±0.4 57.7±0.2</td><td>-0.4</td><td>68.6</td><td>71.7</td><td>49.4</td><td>84.7</td><td>79.0</td><td>37.5</td><td>34.3</td><td>32.4</td><td>76.7</td><td>42.8</td></tr><tr><td>AA</td><td>55.0±0.2</td><td>55.7±0.3</td><td>+0.7</td><td>54.8</td><td>68.3</td><td>43.8</td><td>86.5</td><td>78.8</td><td>34.5</td><td>33.8</td><td>36.1</td><td>77.1</td><td>43.8</td></tr><tr><td>SIN</td><td>52.4±0.1</td><td>55.8±0.3</td><td>+3.4</td><td>54.7</td><td>69.8</td><td>52.8</td><td>79.6</td><td>69.2</td><td>37.8</td><td>35.3</td><td>37.0</td><td>77.3</td><td>44.1</td></tr><tr><td>AugMix</td><td>49.2 ±0.7</td><td>52.4±0.2</td><td>+3.2</td><td>43.2</td><td>72.2</td><td>46.1</td><td>76.3</td><td>67.4</td><td>38.8</td><td>32.4</td><td>32.3</td><td>76.4</td><td>39.2</td></tr><tr><td>PG</td><td>49.3 ±0.2</td><td>56.6±0.4</td><td>+7.3</td><td>60.3</td><td>74.1</td><td>48.5</td><td>82.1</td><td>76.7</td><td>38.9</td><td>34.6</td><td>32.1</td><td>76.5</td><td>42.1</td></tr><tr><td>ANT*</td><td>48.8</td><td>53.9</td><td>+5.1</td><td>35.8</td><td>75.5</td><td>56.9</td><td>76.4</td><td>63.7</td><td>41.0</td><td>35.2</td><td>35.0</td><td>76.1</td><td>43.3</td></tr><tr><td>DA*</td><td>46.6</td><td>51.0</td><td>+4.4</td><td>41.7</td><td>73.3</td><td>53.9</td><td>74.6</td><td>50.9</td><td>37.2</td><td>30.3</td><td>32.9</td><td>74.7</td><td>40.9</td></tr><tr><td>DA+AM*</td><td>41.0</td><td>48.3</td><td>+7.3</td><td>34.9</td><td>67.9</td><td>49.8</td><td>69.7</td><td>48.0</td><td>35.2</td><td>30.6</td><td>32.9</td><td>74.3</td><td>39.8</td></tr><tr><td></td><td>C10-C</td><td colspan="2">C10-C</td><td></td><td></td><td></td><td>CIFAR-10-C</td><td></td><td>Corruptions</td><td></td><td></td><td></td><td></td></tr><tr><td>Aug</td><td>Err</td><td>Err</td><td>△C10-C</td><td>BSmpl Brwn</td><td></td><td>Ckbd</td><td>CBlur]</td><td>ISprk</td><td>Line</td><td>P&amp;T</td><td>Rppl</td><td>Sprk</td><td>TCA</td></tr><tr><td>Baseline</td><td></td><td>27.0±0.6 27.1 ±0.5</td><td>+0.1</td><td>42.9</td><td>27.2</td><td>23.3</td><td>11.8</td><td>43.3</td><td>26.2</td><td>11.3</td><td>21.6</td><td>21.0</td><td>42.9</td></tr><tr><td>AA</td><td>19.4±0.2</td><td>21.0±0.4</td><td>+1.6</td><td>17.7</td><td>17.5</td><td>17.6</td><td>9.5</td><td>40.4</td><td>23.6</td><td>10.7</td><td>23.5</td><td>17.5</td><td>31.8</td></tr><tr><td>AugMix</td><td>11.1±0.2</td><td>16.0±0.3</td><td>+5.9</td><td>9.8</td><td>27.8</td><td>13.4</td><td>5.9</td><td>30.3</td><td>18.0</td><td>8.3</td><td>12.1</td><td>15.5</td><td>19.2</td></tr><tr><td>PG</td><td>17.0±0.3</td><td>23.8±0.5</td><td>+6.8</td><td>9.0</td><td>30.1</td><td>21.6</td><td>12.8</td><td>35.4</td><td>20.6</td><td>8.8</td><td>21.5</td><td>19.3</td><td>59.5</td></tr></table>
+
+Table 2: Comparison of errors on ImageNet-C and ImageNet-C for several robust models: WSL (weakly supervised ResNeXt-101-32x8d [21, 22]), EN (EfficientNet-B0 [32]), NS (Noisy Student EN-B0 [37]), ViT-S (Transformer [7, 34]), ResNeSt (ResNeSt-50d, [41]), using pre-trained models provided with the respective papers. These models do not rely primarily on data augmentation to be robust, and there is no consistent degradation on ImageNet-C. This is additional evidence that the worse performance in Table 1 does not occur because ImageNet-C is harder generally.   
+
+<table><tr><td></td><td>WSL</td><td>EN</td><td>NS</td><td>ViT-S</td><td>ResNeSt</td></tr><tr><td>IN-C Err</td><td>38.1</td><td>55.7</td><td>52.1</td><td>44.5</td><td>44.4</td></tr><tr><td>IN-CErr</td><td>39.2</td><td>53.4</td><td>52.2</td><td>41.1</td><td>41.6</td></tr></table>
+
+It may be surprising that Stylized-ImageNet also degrades, given that it is intuitively very different from every corruption. While our measure works for augmentations, it does not cover all possible methods that improve robustness, such as more complicated algorithms like Stylized-ImageNet. Stylized-ImageNet degradation may be due to other reasons. For instance, it primarily augments texture information and may help mostly with higher frequency corruptions, as can be seen by its improvement on single frequency noise and cocentric sine waves; ImageNet-C has fewer such corruptions than ImageNet-C. ImageNet-C is thus a useful tool for understanding the interaction between training procedure and corruption distribution, even beyond perceptual similarity.
+
+Nevertheless, note that it is the intuitively broader augmentation schemes, such as AutoAugment, AugMix, Stylized-ImageNet, and DeepAugment that generalize better to ImageNet-C. The importance of breadth has also been explored elsewhere[15, 38], but in the previous sections we have provided new quantitative evidence for why this may be true: broad augmentation schemes may be perceptually similar to more types of corruptions, and thus more likely to be perceptually similar to a new corruption. Moreover, AugMix and DeepAugment still improve over baseline on ImageNet-C, so there is reason to be optimistic that robustness to unknown corruptions is an achievable goal, as long as evaluation is treated carefully.
+
+# 6 Discussion
+
+Societal Impact. Our method for finding dissimilar corruptions could in principle be used to adversarially attack computer vision systems, such as those in content moderation or self-driving cars. Moreover, our ultimate goal is to help improve robustness in computer vision, and such robust systems may be used in detrimentals ways, for example in autonomous weapons or surveillance. However, we expect better evaluation of robust models to have definite benefits as well. In the long run, such an understanding should help defend against adversarial attacks. Our tools could also be used to challenge purportedly robust systems that are actually dangerously unreliable, such as an autonomous driving system that is robust to common corruption benchmarks yet fails to be robust to a dissimilar but important corruption, e.g., maybe glare. For instance, is the model employing data augmentation that is perceptually similar to the corruptions being used to report good robustness? Is the set of validation corruptions sufficiently broad that we would expect reasonable generalization to an unseen corruption? If we generate a dissimilar set of corruptions using the procedure we develop here, does the model still perform well on the new corruptions? Quantitative ways to answer these questions may provide a means to verify the robust performance of a model before it encounters and potentially fails on a critical, previously unseen corruption.
+
+Corruption robustness as a secondary learning task. We have provided evidence that data augmentation may not generalize well beyond a given corruption benchmark. To explore this further, consider an analogy to a regular learning problem. We may think of corruption robustness in the presence of data augmentation as a sort of secondary task layered on the primary classification task: the set of data augmentations is the training set, the set of corruptions is the test set, and the goal is to achieve invariance of the underlying primary task. In this language, the ‘datasets’ involved are quite small: ImageNet-C has only 15 corruption types, and several augmentation schemes composite only around 10 basic transforms. In this case, standard machine learning practice would dictate a training/validation/test set split; it is only the size and breadth of modern vision datasets that has allowed this to be neglected in certain cases recently. But the effective dataset size of a corruption robustness problem is tiny, so having a held-out test set seems necessary. To emphasize, this is not a test set of the underlying classification task, for which generalization has been studied by Recht et al. [23, 24]. Instead, it is a test set of corruption transforms themselves. This means there would be validation/test split of dissimilar transformations, both applied to the ImageNet validation set6.
+
+Real-world corruption robustness. Recently, Hendrycks et al. [15] and Taori et al. [33] study how performance on corruption transforms generalizes to real-world corruptions and come to conflicting conclusions. Though we do not study real-world corruptions, we have proposed a mechanism that may explain the conflict: performance will generalize between transforms and real-world corruptions if they are perceptually similar, but will likely not if they are dissimilar. Since Hendrycks et al. [15] and Taori et al. [33] draw on different real-world and synthetic corruptions, it may be that the perceptual similarity between datasets differs in the two analyses. This also suggests a way to find additional corruption transforms that correlate with real-world corruptions: transforms should be sought that have maximal perceptual similarity with real-world corruptions.
+
+Generalization does occur. We have encountered two features of data augmentation that may explain why it can be such a powerful tool for corruption robustness, despite the issues discussed above. First, within a class of perceptually similar transforms, generalization does occur. This means each simple data augmentation may confer robustness to many complicated corruptions, as long as they share perceptual similarity. Second, dissimilar augmentations in an augmentation scheme often causes little to no loss in performance, as long as a similar augmentation is also present. We briefly study this in Appendix A by demonstrating that adding many dissimilar augmentations increases error much less than adding a few similar augmentations decreases it. These two features suggest broad augmentation schemes with many dissimilar augmentations may confer robustness to a large class of unknown corruptions. More generally, we think data augmentation is a promising direction of study for corruption robustness, as long as significant care is taken in evaluation.
+
+# Acknowledgements and Funding Disclosure
+
+Eric Mintun would like to thank Matthew Leavitt, Sho Yaida, and Achal Dave for discussions during the development of this work. Additionally, he would like to acknowledge the Facebook AI residency program for providing excellent training and support in AI research. The authors received no external funding and have no competing interests.
+
+References   
+[1] Bruna, J. and Mallat, S. Invariant scattering convolution networks. IEEE transactions on pattern analysis and machine intelligence, 35(8):1872–1886, 2013.   
+[2] Cubuk, E. D., Zoph, B., Mané, D., Vasudevan, V., and Le, Q. V. AutoAugment: Learning augmentation strategies from data. In CVPR, 2019.   
+[3] Dao, T., Gu, A., Ratner, A. J., Smith, V., De Sa, C., and Ré, C. A kernel theory of modern data augmentation. Proceedings of machine learning research, 97:1528, 2019.   
+[4] Deng, J., Dong, W., Socher, R., Li, L.-J., Li, K., and Fei-Fei, L. ImageNet: A large-scale hierarchical image database. In CVPR, 2009.   
+[5] Ding, K., Ma, K., Wang, S., and Simoncelli, E. P. Image quality assessment: Unifying structure and texture similarity. IEEE transactions on pattern analysis and machine intelligence, 2020.   
+[6] Dodge, S. and Karam, L. A study and comparison of human and deep learning recognition performance under visual distortions. In ICCCN, 2017.   
+[7] 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 ICLR, 2021.   
+[8] Geirhos, R., Temme, C. R., Rauber, J., Schütt, H. H., Bethge, M., and Wichmann, F. A. Generalisation in humans and deep neural networks. In NeurIPS, 2018.   
+[9] Geirhos, R., Rubisch, P., Michaelis, C., Bethge, M., Wichmann, F. A., and Brendel, W. ImageNet-trained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness. In ICLR, 2019.   
+[10] Gladman, S. J. Filterpedia, 2016. URL https://github.com/FlexMonkey/Filterpedia.   
+[11] Goyal, P., Dollár, P., Girshick, R., Noordhuis, P., Wesolowski, L., Kyrola, A., Tulloch, A., Jia, Y., and He, K. Accurate, large minibatch SGD: Training ImageNet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.   
+[12] He, K., Zhang, X., Ren, S., and Sun, J. Deep residual learning for image recognition. In CVPR, 2016.   
+[13] Hendrycks, D. and Dietterich, T. Benchmarking neural network robustness to common corruptions and perturbations. In ICLR, 2018.   
+[14] 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 ICLR, 2019.   
+[15] Hendrycks, D., Basart, S., Mu, N., Kadavath, S., Wang, F., Dorundo, E., Desai, R., Zhu, T., Parajuli, S., Guo, M., Song, D., Steinhardt, J., and Gilmer, J. The many faces of robustness: A critical analysis of out-of-distribution generalization. arXiv preprint arXiv:2006.16241, 2020.   
+[16] Huxtable, J. JH Labs Java Image Processing, 2006. URL http://www.jhlabs.com/ip/ filters/.   
+[17] Krizhevsky, A., Hinton, G., et al. Learning multiple layers of features from tiny images. 2009.   
+[18] Lee, J., Won, T., and Hong, K. Compounding the performance improvements of assembled techniques in a convolutional neural network. arXiv preprint arXiv:2001.06268, 2020.   
+[19] Liang, J., Hu, D., and Feng, J. Do we really need to access the source data? source hypothesis transfer for unsupervised domain adaptation. In International Conference on Machine Learning, pp. 6028–6039. PMLR, 2020.   
+[20] Lopes, R. G., Yin, D., Poole, B., Gilmer, J., and Cubuk, E. D. Improving robustness without sacrificing accuracy with Patch Gaussian augmentation. arXiv preprint arXiv:1906.02611, 2019.   
+[21] Mahajan, D., Girshick, R., Ramanathan, V., He, K., Paluri, M., Li, Y., Bharambe, A., and van der Maaten, L. Exploring the limits of weakly supervised pretraining. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 181–196, 2018.   
+[22] Orhan, A. E. Robustness properties of Facebook’s ResNeXt WSL models. arXiv preprint arXiv:1907.07640, 2019.   
+[23] Recht, B., Roelofs, R., Schmidt, L., and Shankar, V. Do CIFAR-10 classifiers generalize to CIFAR-10? arXiv preprint arXiv:1806.00451, 2018.   
+[24] Recht, B., Roelofs, R., Schmidt, L., and Shankar, V. Do ImageNet classifiers generalize to ImageNet? In ICML, 2019.   
+[25] Rusak, E., Schott, L., Zimmermann, R., Bitterwolf, J., Bringmann, O., Bethge, M., and Brendel, W. A simple way to make neural networks robust against diverse image corruptions. arXiv preprint arXiv:2001.06057, 2020.   
+[26] Schneider, S., Rusak, E., Eck, L., Bringmann, O., Brendel, W., and Bethge, M. Improving robustness against common corruptions by covariate shift adaptation. In NeurIPS, 2020.   
+[27] Shankar, V., Dave, A., Roelofs, R., Ramanan, D., Recht, B., and Schmidt, L. Do image classifiers generalize across time? arXiv preprint arXiv:1906.02168, 2019.   
+[28] Simard, P. Y., LeCun, Y. A., Denker, J. S., and Victorri, B. Transformation invariance in pattern recognition—tangent distance and tangent propagation. In Neural networks: tricks of the trade, pp. 239–274. Springer, 1998.   
+[29] Simonyan, K. and Zisserman, A. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   
+[30] Sun, Y., Wang, X., Liu, Z., Miller, J., Efros, A., and Hardt, M. Test-time training with selfsupervision for generalization under distribution shifts. In International Conference on Machine Learning, pp. 9229–9248. PMLR, 2020.   
+[31] Szegedy, C., Zaremba, W., Sutskever, I., Bruna, J., Erhan, D., Goodfellow, I., and Fergus, R. Intriguing properties of neural networks. In ICLR, 2014.   
+[32] Tan, M. and Le, Q. EfficientNet: Rethinking model scaling for convolutional neural networks. In ICML, 2019.   
+[33] Taori, R., Dave, A., Shankar, V., Carlini, N., Recht, B., and Schmidt, L. Measuring robustness to natural distribution shifts in image classification. In NeurIPS, 2020.   
+[34] Touvron, H., Cord, M., Douze, M., Massa, F., Sablayrolles, A., and Jégou, H. Training dataefficient image transformers & distillation through attention. arXiv preprint arXiv:2012.12877, 2020.   
+[35] Wang, D., Shelhamer, E., Liu, S., Olshausen, B., and Darrell, T. Tent: Fully test-time adaptation by entropy minimization. ICLR, 2021.   
+[36] Wu, S., Zhang, H. R., Valiant, G., and Ré, C. On the generalization effects of linear transformations in data augmentation. In ICML, 2020.   
+[37] Xie, Q., Luong, M.-T., Hovy, E., and Le, Q. V. Self-training with Noisy Student improves imagenet classification. In CVPR, 2020.   
+[38] Yin, D., Lopes, R. G., Shlens, J., Cubuk, E. D., and Gilmer, J. A Fourier perspective on model robustness in computer vision. In NeurIPS, 2019.   
+[39] Zagoruyko, S. and Komodakis, N. Wide residual networks. In BMVC, 2016.   
+[40] Zhang, H., Cisse, M., Dauphin, Y. N., and Lopez-Paz, D. mixup: Beyond empirical risk minimization. In ICLR, 2018.   
+[41] Zhang, H., Wu, C., Zhang, Z., Zhu, Y., Zhang, Z., Lin, H., Sun, Y., He, T., Muller, J., Manmatha, R., Li, M., and Smola, A. ResNeSt: Split-Attention Networks. arXiv preprint arXiv:2004.08955, 2020.   
+[42] Zhang, R., Isola, P., Efros, A. A., Shechtman, E., and Wang, O. The unreasonable effectiveness of deep features as a perceptual metric. In CVPR, 2018.   
+[43] Zilly, J., Zilly, H., Richter, O., Wattenhofer, R., Censi, A., and Frazzoli, E. The Frechet Distance of training and test distribution predicts the generalization gap. OpenReview preprint, 2019. URL https://openreview.net/forum?id $\cdot ^ { = }$ SJgSflHKDr.

parse/train/LOHyqjfyra/LOHyqjfyra_content_list.json

@@ -0,0 +1,830 @@
+[
+    {
+        "type": "text",
+        "text": "On Interaction Between Augmentations and Corruptions in Natural Corruption Robustness ",
+        "text_level": 1,
+        "bbox": [
+            215,
+            122,
+            784,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Eric Mintun∗ Facebook AI Research mintun@fb.com ",
+        "bbox": [
+            220,
+            226,
+            370,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Alexander Kirillov Facebook AI Research akirillov@fb.com ",
+        "bbox": [
+            424,
+            226,
+            573,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Saining Xie Facebook AI Research s9xie@fb.com ",
+        "bbox": [
+            627,
+            226,
+            777,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            304,
+            535,
+            320
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Invariance to a broad array of image corruptions, such as warping, noise, or color shifts, is an important aspect of building robust models in computer vision. Recently, several new data augmentations have been proposed that significantly improve performance on ImageNet-C, a benchmark of such corruptions. However, there is still a lack of basic understanding on the relationship between data augmentations and test-time corruptions. To this end, we develop a feature space for image transforms, and then use a new measure in this space between augmentations and corruptions called the Minimal Sample Distance to demonstrate a strong correlation between similarity and performance. We then investigate recent data augmentations and observe a significant degradation in corruption robustness when the test-time corruptions are sampled to be perceptually dissimilar from ImageNet-C in this feature space. Our results suggest that test error can be improved by training on perceptually similar augmentations, and data augmentations may not generalize well beyond the existing benchmark. We hope our results and tools will allow for more robust progress towards improving robustness to image corruptions. We provide code at https://github.com/facebookresearch/augmentation-corruption. ",
+        "bbox": [
+            233,
+            335,
+            766,
+            556
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            582,
+            310,
+            599
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Robustness to distribution shift, i.e. when the train and test distributions differ, is an important feature of practical machine learning models. Among many forms of distribution shift, one particularly relevant category for computer vision are image corruptions. For example, test data may come from sources that differ from the training set in terms of lighting, camera quality, or other features. Postprocessing transforms, such as photo touch-up, image filters, or compression effects are commonplace in real-world data. Models developed using clean, undistorted inputs typically perform dramatically worse when confronted with these sorts of image corruptions [8, 13]. The subject of corruption robustness has a long history in computer vision [1, 6, 28] and recently has been studied actively with the release of benchmark datasets such as ImageNet-C [13]. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            739
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One particular property of image corruptions is that they are low-level distortions in nature. Corruptions are transformations of an image that affect structural information such as colors, textures, or geometry [5] and are typically free of high-level semantics. Therefore, it is natural to expect that data augmentation techniques, which expand the training set with random low-level transformations, can help learn robust models. Indeed, data augmentation has become a central technique in several recent methods [14, 20, 25] that achieve large improvements on ImageNet-C and related benchmarks. ",
+        "bbox": [
+            174,
+            744,
+            825,
+            829
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One caveat for data augmentation based approaches is the test corruptions are expected to be unknown at training time. If the corruptions are known, they may simply be applied to the training set as data augmentations to trivially adapt to the test distribution. Instead, an ideal robust model needs to be robust to any valid corruption, including ones unseen in any previous benchmark. Of course, in practice the robustness of a model can only be evaluated approximately by measuring its corruption error on a representative corruption benchmark. To avoid trivial adaptation to the benchmark, recent works manually exclude test corruptions from the training augmentations. However, with a toy experiment presented in Figure 1, we argue that this strategy alone might not be enough and that visually similar augmentation outputs and test corruptions can lead to significant benchmark improvements even if the exact corruption transformations are excluded. ",
+        "bbox": [
+            176,
+            835,
+            823,
+            877
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/fe090e63eeb377f94bef1f6849361fcdef3729355d87e25cbd42014e40b03afb.jpg",
+        "image_caption": [
+            "Figure 1: A toy experiment. We train multiple models on CIFAR-10 [17] using different augmentation schemes. Each scheme is based on a single basic image transformation type and enhanced by overlaying random instantiations of the transformation for each input image following Hendrycks et al. [14]. We compare these models on the CIFAR-10 test set corrupted by the motion blur, a corruption used in the ImageNet-C corruption benchmark [13]. None of the augmentation schemes contains motion blur; however, the models trained with geometric-based augmentations significantly outperform the baseline model trained on the clean images while color-based augmentations show no gains. We note the geometric augmentations can produce a result visually similar to a blur by overlaying copies of shifted images3. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            87,
+            818,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            398,
+            825,
+            496
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This observation raises two important questions. One, how exactly does the similarity between train time augmentations and corruptions of the test set affect the error? And two, if the gains are due to the similarity, they may not translate into better robustness to other possible corruptions, so how well will data augmentations generalize beyond a given benchmark? In this work, we take a step towards answering these questions, with the goal of better understanding the relationship between data augmentation and test-time corruptions. Using a feature space on image transforms and a new measure called Minimal Sample Distance (MSD) on this space, we are able to quantify the distance between augmentation schemes and classes of corruption transformation. With our approach, we empirically show an intuitive yet surprisingly overlooked finding: ",
+        "bbox": [
+            174,
+            502,
+            825,
+            627
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Augmentation-corruption perceptual similarity is a strong predictor of corruption error. ",
+        "bbox": [
+            173,
+            640,
+            745,
+            655
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Based on this finding, we perform additional experiments to show that data augmentation aids corruption robustness by increasing perceptual similarity between a (possibly small) fraction of the training data and the test set. To further support our claims, we introduce a set of new corruptions, called CIFAR/ImageNet-C, to test the degree to which common data augmentation methods generalize from the original CIFAR/ImageNet-C. To choose these corruptions, we expand the set of natural corruptions and sample new corruptions that are far away from CIFAR/ImageNet-C in our feature space for measuring perceptual similarity. We then demonstrate that augmentation schemes designed specifically to improve robustness show significantly degraded performance on CIFAR/ImageNet-C. Some augmentation schemes still show some improvement over baseline, which suggests meaningful progress towards general corruption robustness is being made, but different augmentation schemes exhibit different degrees of generalization capability. As an implication, caution is needed for fair robustness evaluations when additional data augmentation is introduced. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "These results suggest a major challenge that is often overlooked in the study of corruption robustness: generalization is often poor. Since perceptual similarity can predict performance, for any fixed finite set of test corruptions, improvements on that set may generalize poorly to dissimilar corruptions. We hope that these results, tools, and benchmarks will help researchers better understand why a given augmentation scheme has good corruption error and whether it should be expected to generalize to dissimilar corruptions. On the positive side, our experiments show that generalization does emerge among perceptually similar transforms, and that only a small fraction of sampled augmentations need to be similar to a given corruption. Section 6 discusses these points in more depth. ",
+        "bbox": [
+            178,
+            840,
+            821,
+            882
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            161
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            180,
+            321,
+            196
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Corruption robustness benchmarks and analysis. ImageNet-C [13] is a corruption dataset often used as a benchmark in robustness studies. Other corruption datasets [15, 27] collect corrupted images from real world sources and thus have a mixture of semantic distribution shifts and perceptual transforms. Corruption robustness differs from adversarial robustness [31], which seeks invariance to small, worst case distortions. One notable difference is that improving corruption robustness often slightly improves regular test error, instead of harming it. Yin et al. [38] analyzes corruption robustness in the context of transforms’ frequency spectra; this can also influence corruption error independently from perceptual similarity. Here we study the relationship between augmentations and corruptions more generically, and explore the relationship between perceptual similarity and generalization to new corruptions. Dao et al. [3] and Wu et al. [36] study the theory of data augmentation for regular test error. Hendrycks et al. [15] and Taori et al. [33] study how the performance on synthetic corruption transforms generalizes to performance on corruption datasets collected from the real world. Here we do not address this issue directly but touch upon it in the discussion. ",
+        "bbox": [
+            174,
+            212,
+            825,
+            391
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Improving corruption robustness. Data augmentations designed to improve robustness include AugMix [14], which composites common image transforms, Patch Gaussian [20], which applies Gaussian noise in square patches, and ANT [25], which augments with an adversarially learned noise distribution. AutoAugment [2] learns augmentation policies that optimize clean error but has since been shown to improve corruption error [38]. Mixup [40] can improve robustness [18], but its label augmentation complicates the dependence on image augmentation. Stylized-ImageNet [9], which applies style transfer to input images, can also improve robustness. DeepAugment [15], which applies augmentations to a deep representation of an image, can also give large improvements in robustness. Noisy Student [37] and Assemble-ResNet [18] combine data augmentation with new models and training procedures and greatly enhance corruption robustness. In addition to training-time methods, there are approaches that adapt to unseen corruptions at test time, e.g. using self-supervised tasks [30], entropy minimization [35], or with a focus on privacy and data transmission efficiency [19]. While we do not directly address these approaches here, our methods potentially provide tools that could be used to measure shifting distributions in an online regime. ",
+        "bbox": [
+            174,
+            407,
+            825,
+            601
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Perceptual similarity for augmentations and corruptions ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            619,
+            676,
+            637
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "First, we study the importance of similarity between augmentations and corruptions for improving performance on those corruptions. To do so, we need a means to compare augmentations and corruptions. Both types of transforms are perceptual in nature, meaning they affect low-level image structure while leaving high-level semantic information intact, so we expect a good distance to be a measure of perceptual similarity. Then, we need to find the appropriate measure of distance between the augmentation and corruption distributions. We will argue below that distributional equivalence is not appropriate in the context of corruption robustness, and instead introduce the minimal sample distance, a simple measure that does capture a relevant sense of distribution distance. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            762
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Measuring similarity between perceptual transforms. We define a perceptual transform as a transform that acts on low-level image structure but not high-level semantic information. As such, we expect two transforms should be similar if their actions on this low-level structure are similar, independent of algorithmic or per-pixel differences between them. A closely related, well-studied problem is the perceptual similarity between images. A common approach is to train a neural network on a classification task and use intermediate layers as a feature space for measuring distances [42]. We adapt this idea to obtain a feature space for measuring distances between perceptual transforms. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We start with a feature extractor for images, which we call $\\hat { f } ( x )$ . To train the model from which we will extract features, we assume access to a dataset $\\mathbb { D }$ of image label pairs $( x , y )$ associated with a classification task. The model should be trained using only default data augmentation for the task in question so that the feature extractor is independent of the transforms we will use it to study. In order to obtain a very simple measure, we use just the last hidden layer of the network as a feature space. ",
+        "bbox": [
+            174,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/8506044a99d204381d92eb25f104590e102c5d67dd35b62b1721d2730c035e11.jpg",
+        "image_caption": [
+            "Figure 2: (a) Schematic comparison of MMD to MSD. MMD measures the distance between distribution centers and is only small if the augmentation overlaps with a corruption. MSD measures to the nearest sampled point in the set of samples (marked by a star) and is small even for broad distributions that overlap with multiple corruptions. (b) We test on images corrupted with impulse noise, and train on images augmented with a mixture of impulse noise and motion blur. As the mixing fraction of impulse noise decreases, MMD between the augmentation and corruption grows linearly while MSD and error stay low until nearly $0 \\%$ mixing fraction. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            305,
+            88,
+            687,
+            243
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            366,
+            823,
+            409
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A perceptual transform $t ( x )$ may be encoded by applying it to all images in $\\mathbb { D }$ , encoding the transformed images, and averaging the features over these images. For efficiency, we find it sufficient to average over only a randomly sampled subset of images $\\mathbb { D } _ { S }$ in $\\mathbb { D }$ . In Section 4.1 we discuss the size of $\\mathbb { D } _ { S }$ . The random choice of images is a property of the feature extractor, and so remains fixed when encoding multiple transforms. This reduces variance when computing distances between two transforms. The transform feature extractor is given by $f ( t ) = \\mathbb { E } _ { x \\in \\mathbb { D } _ { S } } [ \\hat { f } ( t ( x ) ) - \\hat { f } ( x ) ]$ . The perceptual similarity between an augmentation and a corruption can be taken as the $L _ { 2 }$ distance on this feature space $f$ . ",
+        "bbox": [
+            173,
+            414,
+            825,
+            529
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Minimal sample distance. We now seek to compare the distribution of an augmentation scheme $p _ { a }$ to a distribution of a corruption benchmark $p _ { c }$ . If the goal was to optimize error on a known corruption distribution, exact equivalence of distributions is the correct measure to minimize. But since the goal is robustness to general, unknown corruption distributions, a good augmentation scheme should be equivalent to no single corruption distribution. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            617
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To illustrate this behavior, consider a toy problem where we have access to the corruption transforms at training time. A very rough, necessary-but-insufficient measure of distributional similarity is $d _ { \\mathrm { M M D } } ( p _ { a } , p _ { c } ) = | | \\mathbb { E } _ { a \\sim p _ { a } } [ f ( a ) ] - \\mathbb { E } _ { c \\sim p _ { c } } [ f ( c ) ] | |$ . This is the maximal mean discrepancy on a fixed, finite feature space, so for brevity we will refer to it as MMD. We still employ the featurization $f ( t )$ , since we are comparing transforms and not images, unlike in typical domain adaptation. Consider two corruption distributions, here impulse noise and motion blur, and an augmentation scheme that is a mixture of the two corruption distributions. Figure 2b shows MMD between the augmentation and impulse noise corruption scales linearly with mixing fraction, but error on impulse noise remains low until the mixing fraction is almost $0 \\%$ impulse noise. This implies distributional similarity is a poor predictor of corruption error. Indeed, low $d _ { \\mathrm { M M D } }$ with any one corruption distribution suggests the augmentation overlaps it significantly, so the augmentation is unlikely to aid dissimilar corruptions. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            776
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our expectation for the behavior of the error in Figure 2b is that networks can often successfully memorize rare examples seen during training, so that only a very small fraction of sampled images need impulse noise augmentations to perform well on impulse noise corruptions. An appropriate distance should then measure how close augmentation samples can come to the corruption distribution, even if the density of those samples is low. We thus propose a very simple measure called minimal sample distance (MSD), which is just the perceptual similarity between an average corruption and the closest augmentation from a finite set of samples A $\\sim p _ { a }$ : ",
+        "bbox": [
+            174,
+            781,
+            825,
+            880
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0686254e09951ecefb074f2292b6e02d1d9d2d7b7574d73c7b445d361a4916a0.jpg",
+        "text": "$$\nd _ { \\mathrm { M S D } } ( p _ { a } , p _ { c } ) = \\operatorname* { m i n } _ { a \\in \\mathbb { A } \\sim p _ { a } } \\left| | f ( a ) - \\mathbb { E } _ { c \\sim p _ { c } } [ f ( c ) ] | \\right| .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            890,
+            658,
+            915
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/33d3208269f30287d53a25941c7a175d6582d601676ec3c3f6f7abd703715409.jpg",
+        "image_caption": [
+            "18 7.012 6.0Figure 3: Example relationships between MSD and corruption error. $\\rho$ is the Spearman rank 16 200.2 0.4 0.6 0.8 0.4 0.8 1.2 1.612 0.10 0.14 0.18 0.22correlation. MSD correlates well with error across all four categories of corruption in CIFAR-10-C. 14 16 Minimal Sample DistanceFor completeness, we also show brightness, a negative example where correlation is poor. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            92,
+            816,
+            193
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "0.2 0.4 0.6 0.8 0.4 0.8 1.2 1.6 0.10 0.14 0.18 0.22A schematic comparison of MMD and MSD is shown in Figure 2a. While both MMD and MSD Minimal Sample Distanceare small for an augmentation scheme that is distributionally similar to a corruption distribution, only MSD remains small for a broad distribution that occasionally produces samples near multiple corruption distributions. Figure 2b shows MSD, like test error, is small for most mixing fractions in the toy problem described above. Note the measure’s need to accommodate robustness to general, unknown corruption distributions has led it to be asymmetric, so it differs from more formal distance metrics that may be used to predict generalization error, such as the Wasserstein distance [43]. ",
+        "bbox": [
+            173,
+            256,
+            825,
+            353
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Perceptual similarity is predictive of corruption error ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            373,
+            650,
+            392
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We are now equipped to measure how important this augmentation-corruption similarity is for corruption error. For a large number of augmentation schemes, we will measure both the MSD to a corruption distribution and the corruption error of a model trained with that scheme. We will find a correlation between MSD and corruption error, which provides evidence that networks generalize across perceptually similar transforms. Then, we will calculate MSD for augmentation schemes in the literature that have been shown to improve error on corruption benchmarks. We will find a correlation between MSD and error here as well, suggesting their success is in part explained by their perceptual similarity to the benchmark. This implies there may be a risk of poor generalization to different benchmarks, since we would not expect this improvement to transfer to a dissimilar corruption. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            531
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experimental setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            549,
+            349,
+            563
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Corruptions. We use CIFAR-10-C [13], which is a common benchmark used for studying corruption robustness. It consists of 15 corruptions, each further split into five different severities of transformation, applied to the CIFAR-10 test set. The 15 corruptions fall into four categories: per-pixel noise, blurring, synthetic weather effects, and digital transforms. We treat each corruption at each severity as a separate distribution for the sake of calculating MSD and error; however, for simplicity we average errors and distances over severity to present a single result per corruption. ",
+        "bbox": [
+            174,
+            574,
+            825,
+            659
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Space of augmentation schemes. To build each sampled augmentation transform, we will composite a set of base augmentations. For base augmentations, we consider the nine common image transforms used in Hendrycks et al. [14]. There are five geometric transforms and four color transforms. By taking all subsets of these base augmentations, we obtain $2 ^ { 9 } = 5 1 2$ unique augmentation schemes, collectively called the augmentation powerset. Also following Hendrycks et al. [14], we composite transforms in two ways: by applying one after another, or by applying them to copies of the image and then linearly superimposing the results. Examples of both augmentations and corruptions are provided in Appendix F. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            785
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Computing similarity and corruption error. A WideResNet-40-2 [39] model is pre-trained on CIFAR-10 using default augmentation and training parameters from Hendrycks et al. [14]. WideResNet is a common baseline model used when studying data augmentation on CIFAR-10 [2, 14, 40]. Its last hidden layer is used as the feature space. For MSD, we average over 100 images, 100 corruptions, and minimize over $1 0 0 \\mathrm { k }$ augmentations. With this number of corruptions and images, we find that the average standard deviation in distance between an augmentation and the averaged corruptions is roughly five percent of the mean, which is smaller than the typical feature in our results found below, given in Figure 3. We also find that using VGG [29] instead of WideResNet for the feature extractor ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/754ebcaed957914f40b406c3c5651bb1eefe20c091f79274177833423931217a.jpg",
+        "image_caption": [
+            "25 w/ solarize w/ x-translationFigure 4: Example relationships between base augmentations and corruptions. Including solarize 10reduces MSD on the perceptually similar impulse noise corruption. Including $x$ translation reduces 20MSD on the perceptually similar motion blur corruption. MSD is not decreased for dissimilar Minimum Sample D    augmentation-corruption pairs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            92,
+            813,
+            227
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "10gives similar results. Details for these calculations are in Appendix C. Images for calculating MSD are from the training set and do not have default training augmentation. A WideResNet-40-2 with the 0.2 0.6 1.0 1.4 0.2 0.6 1.0 1.4same training parameters is used for corruption error evaluation. ",
+        "bbox": [
+            176,
+            305,
+            821,
+            347
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            364,
+            271,
+            378
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "MSD correlates with corruption error. First, we establish the correlation between MSD and corruption error on the augmentation powerset. MSD shows strong correlation with corruption error across corruptions types in all four categories of CIFAR-10-C, and for a large majority of CIFAR-10-C corruptions in general: 12 of 15 have Spearman rank correlation greater than 0.6. Figure 3 shows the relationship between distance and corruption error on six example corruptions, including one negative example for which correlation is low. A complete set of plots is below in Figure 5. This corruption, brightness, may give poor results because it is a single low-level image statistic that can vary significantly from image to image, and thus may not be well represented by our feature extractor. Appendix B has a few supplemental experiments. First, we we confirm MMD correlates poorly with corruption error, as expected. In particular, we expect broad augmentation schemes produce samples similar to a larger set of corruptions, leading to both lower MSD and lower corruption error but higher MMD. Second, we repeat our experiment but do not train on the augmentations, instead only adapting the batch norm statistics of a pre-trained model to them. We still find a strong correlation, suggesting our methods are compatible with the results of Schneider et al. [26], which shows such an adaptation of the batch norm statistics to a corruption can improve corruption error. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            597
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "An example of perceptual similarity. Here we illustrate the perceptual nature of the similarity measure, using an example with two base augmentations and two corruptions. The augmentation solarize and the corruption impulse noise both insert bright pixels into the image, though in different ways. Linear superpositions of the augmentation $x$ translation are visually similar to a blur, such as the corruption motion blur. Figure 4 shows MSD vs error where augmentation schemes that include solarize and $x$ translation are colored. It is clear that including an augmentation greatly decreases MSD to its perceptually similar corruption, while having little effect on MSD to its perceptually dissimilar corruption. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            723
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "MSD and corruption error in real augmentation methods. The augmentation powerset may be used as a baseline for comparing real data augmentation schemes. Figure 5 shows MSD-error correlations for Patch Gaussian [20], AutoAugment [2], and Augmix [14], along with the cloud of augmentation powerset points for all 15 CIFAR-10-C corruptions. The real augmentation schemes follow the same general trend that lower error predicts lower MSD. A few intuitive correlations are also captured in Figure 5. Patch Gaussian has low MSD to noise corruptions. AutoAugment, which contains contrast and Gaussian blurring augmentations in its sub-policies, has low MSD with contrast and defocus blur. A negative example is fog, on which MSD to AutoAugment is not predictive of corruption error. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            863
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This correlation suggests generalization may be poor beyond an existing benchmark, since an augmentation scheme may be perceptually similar to one benchmark but not another. For augmentations and corruptions that are explicitly the same, such as contrast in AutoAugment and ImageNet-C, this is typically accounted for by removing such transforms from the augmentation scheme when testing corruption robustness4. But in addition to these explicit similarities, Figure 5 shows quantitatively that perceptual similarity between non-identical augmentations and corruptions is also strongly predictive of corruption error. This includes possibly unexpected similarities, such as between Patch Gaussian and glass blur, which introduces random pixel-level permutations as noise. This suggests that perceptually similar augmentations and corruptions should be treated with the same care as identical transforms. In particular, tools such as MSD help us determine why an augmentation scheme improves corruption error, so we can better understand if new methods will generalize beyond their tested benchmarks. Next we test this generalization by finding corruptions dissimilar to ImageNet-C. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/d4816a08ab544b8902c76e2ed306197c37edf23422e76c702e28ac2d93da066d.jpg",
+        "image_caption": [
+            "Figure 5: Correlations for augmentation schemes from the literature. Patch Gaussian is similar to noise, while AutoAugment is similar to contrast and blur, as expected from their formulation. Glass blur acts more like a noise corruption than a blur for these augmentation schemes, likely because it randomly permutes pixels. As a negative example, MSD does not correlate well with error for AutoAugment on fog. \\*AugMix here refers to just the augmentation distribution in Hendrycks et al. [14], not the proposed Jensen-Shannon divergence loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            820,
+            421
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            529,
+            825,
+            654
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 ImageNet-C: benchmarking with dissimilar corruptions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            672,
+            673,
+            690
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now introduce a set of corruptions, called ImageNet-C, that are perceptually dissimilar to ImageNet-C in our transform feature space, and we will show that several augmentation schemes have degraded performance on the new dataset. We emphasize that the dataset selection method uses only default data augmentation and was fixed before we looked at the results for different augmentations, so we are not adversarially selecting against the tested augmentation schemes. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            776
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Dataset construction. Here we present an overview of the dataset construction method. We build 30 new corruptions in 10 severities, from which the 10 most dissimilar corruptions will be chosen. We adapt common filters and noise distributions available online [10, 16] to produce human interpretable images. The transforms include warps, blurs, color distortions, noise additions, and obscuring effects. Examples of the new corruptions and exact details of the construction method are provided in Appendices D and F. ",
+        "bbox": [
+            173,
+            791,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/47e802717f039011da8d3fa76d9b4cc61d83551f82c9eb8df720c25f4de6d572.jpg",
+        "image_caption": [
+            "Brown Noise Checkerboard Cocentric Sine Waves Perlin Noise Single Frequency NoiseImageNet-C CorruptionsFigure 6: Example CIFAR-10-C and ImageNet-C corruptions. While still human interpretable, new corruptions are sampled to be dissimilar from CIFAR-10/ImageNet-C. Base images $^ ©$ Sehee Park and Chenxu Han. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            89,
+            820,
+            210
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Blue Noise Sample Caustic Refraction Inverse Sparkle Plasma Noise SparklesTo assure that the new dataset is no harder than ImageNet-C, we restrict the average corruption error of the new dataset to be similar to that of ImageNet-C for default augmentation. We then generate many potential datasets and measure the average shift in distance to ImageNet-C that each corruption contributes. Note that while MSD is a measure between augmentations and corruptions, here we are comparing corruptions to other corruptions and thus use MMD in our transform feature space. ImageNet-C then consists of the 10 corruptions types with the largest average shift in distance. Like ImageNet-C, each has five different severities, with severities chosen so that the average error matches ImageNet-C for default augmentation. Example transforms from ImageNet-C and CIFAR-10-C are shown in Figure 6. This procedure in our feature space produces corruptions intuitively dissimilar from ImageNet-C and CIFAR-10-C. ",
+        "bbox": [
+            174,
+            277,
+            825,
+            416
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results. We test AutoAugment [2], Patch Gaussian [20], AugMix [14], $\\mathbf { A N T } ^ { 3 \\mathrm { x } 3 }$ [25], StylizedImageNet [9], and DeepAugment [15] on our new datasets and show results in Table 1. CIFAR-10 models are WideResNet-40-2 with training parameters from Hendrycks et al. [14]. ImageNet [4] models are ResNet-50 [12] with training parameters from Goyal et al. [11]. Stylized-ImageNet is trained jointly with ImageNet for half the epochs and starts from a model pre-trained on ImageNet, following Geirhos et al. [9]. Models use default data augmentation as well as the augmentation being tested, except ImageNet color jittering is not used. All corruptions are applied in-memory instead of loaded from a compressed file; this can affect results especially on high frequency corruptions. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            547
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Since Section 4 suggests several augmentation schemes are perceptually similar to ImageNet-C corruptions, we might expect these methods to have worse error on the new corruptions. Indeed, every augmentation scheme performs worse. Different augmentation schemes also degrade by significantly different amounts, from $+ 0 . 7 \\%$ for AutoAugment to $+ 7 . 3 \\%$ for PatchGaussian, which changes their ranking by corruption error and leads to inconsistency of generalization. In Table 2, we compare performance on several robust models[7, 21, 22, 32, 34, 37, 41] that are not primarily augmentationbased and see no similar pattern of degradation, further suggesting that augmentation-corruption dissimilarity is the cause of the higher error. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            665
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Errors of individual corruptions in ImageNet-C are also revealing. For all augmentation schemes, there is significant improvement on blue sample noise5 but little improvement on sparkles or inverse sparkles. Only AutoAugment does well on checkerboard, perhaps because only AutoAugment’s geometric transforms produce empty space, similar to checkerboard’s occluded regions. These examples suggest a slightly different benchmark could yield significantly different results. Indeed, for a hypothetical benchmark that excluded blue sample noise and checkerboard, AutoAugment and Patch Gaussian have $5 7 . 3 \\%$ and $5 7 . 2 \\%$ error respectively, little better than baseline of $5 7 . 4 \\%$ . AugMix fairs only a little better with $5 4 . 3 \\%$ error. Even DeepAugment+AugMix, which is in general a strong augmentation scheme, shows a big discrepancy in performance across different corruptions, improving single frequency noise by $31 \\%$ , but inverse sparkles by only $2 . 3 \\%$ . Generalization to dissimilar corruptions is thus both inconsistent and typically quite poor. Single benchmarks and aggregate corruption scores are likely not enough for careful evaluation of robustness to unknown corruptions, and it is important to study why proposed augmentations succeed to better understand how well they might generalize. ",
+        "bbox": [
+            174,
+            670,
+            826,
+            864
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/a1ef0e9fee28328e33fb237931540e612574585409f5bc3558ad0c4d6c59ef64.jpg",
+        "table_caption": [
+            "Table 1: Test error for several data augmentation methods on CIFAR-10-C and ImageNet-10- $\\overline { { C } }$ , for which every method performs worse than on ImageNet-C or CIFAR-10-C. The increase in error differs significantly between different augmentation methods. Descriptions of the abbreviations and standard deviations for individual corruptions are in Appendix D. ‘Baseline’ refers to default augmentation only. Averages are over five runs for ImageNet and ten for CIFAR-10. \\*ANT, DeepAugment(DA) and DeepAugment+AugMix $( \\mathrm { D A } { + } \\mathrm { A M } )$ use the pre-trained model provided with the associated papers and have different training parameters. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Aug</td><td rowspan=\"2\">IN-C Err</td><td colspan=\"2\">IN-C</td><td colspan=\"10\">ImageNet-C Corruptions</td></tr><tr><td>Err</td><td>△IN-C</td><td>BSmpl Plsm</td><td></td><td>Ckbd</td><td>CSin</td><td>SFrq</td><td>Brwn</td><td>Prln</td><td>Sprk</td><td>ISprk</td><td>Rfrac</td></tr><tr><td>Baseline</td><td></td><td>58.1±0.4 57.7±0.2</td><td>-0.4</td><td>68.6</td><td>71.7</td><td>49.4</td><td>84.7</td><td>79.0</td><td>37.5</td><td>34.3</td><td>32.4</td><td>76.7</td><td>42.8</td></tr><tr><td>AA</td><td>55.0±0.2</td><td>55.7±0.3</td><td>+0.7</td><td>54.8</td><td>68.3</td><td>43.8</td><td>86.5</td><td>78.8</td><td>34.5</td><td>33.8</td><td>36.1</td><td>77.1</td><td>43.8</td></tr><tr><td>SIN</td><td>52.4±0.1</td><td>55.8±0.3</td><td>+3.4</td><td>54.7</td><td>69.8</td><td>52.8</td><td>79.6</td><td>69.2</td><td>37.8</td><td>35.3</td><td>37.0</td><td>77.3</td><td>44.1</td></tr><tr><td>AugMix</td><td>49.2 ±0.7</td><td>52.4±0.2</td><td>+3.2</td><td>43.2</td><td>72.2</td><td>46.1</td><td>76.3</td><td>67.4</td><td>38.8</td><td>32.4</td><td>32.3</td><td>76.4</td><td>39.2</td></tr><tr><td>PG</td><td>49.3 ±0.2</td><td>56.6±0.4</td><td>+7.3</td><td>60.3</td><td>74.1</td><td>48.5</td><td>82.1</td><td>76.7</td><td>38.9</td><td>34.6</td><td>32.1</td><td>76.5</td><td>42.1</td></tr><tr><td>ANT*</td><td>48.8</td><td>53.9</td><td>+5.1</td><td>35.8</td><td>75.5</td><td>56.9</td><td>76.4</td><td>63.7</td><td>41.0</td><td>35.2</td><td>35.0</td><td>76.1</td><td>43.3</td></tr><tr><td>DA*</td><td>46.6</td><td>51.0</td><td>+4.4</td><td>41.7</td><td>73.3</td><td>53.9</td><td>74.6</td><td>50.9</td><td>37.2</td><td>30.3</td><td>32.9</td><td>74.7</td><td>40.9</td></tr><tr><td>DA+AM*</td><td>41.0</td><td>48.3</td><td>+7.3</td><td>34.9</td><td>67.9</td><td>49.8</td><td>69.7</td><td>48.0</td><td>35.2</td><td>30.6</td><td>32.9</td><td>74.3</td><td>39.8</td></tr><tr><td></td><td>C10-C</td><td colspan=\"2\">C10-C</td><td></td><td></td><td></td><td>CIFAR-10-C</td><td></td><td>Corruptions</td><td></td><td></td><td></td><td></td></tr><tr><td>Aug</td><td>Err</td><td>Err</td><td>△C10-C</td><td>BSmpl Brwn</td><td></td><td>Ckbd</td><td>CBlur]</td><td>ISprk</td><td>Line</td><td>P&amp;T</td><td>Rppl</td><td>Sprk</td><td>TCA</td></tr><tr><td>Baseline</td><td></td><td>27.0±0.6 27.1 ±0.5</td><td>+0.1</td><td>42.9</td><td>27.2</td><td>23.3</td><td>11.8</td><td>43.3</td><td>26.2</td><td>11.3</td><td>21.6</td><td>21.0</td><td>42.9</td></tr><tr><td>AA</td><td>19.4±0.2</td><td>21.0±0.4</td><td>+1.6</td><td>17.7</td><td>17.5</td><td>17.6</td><td>9.5</td><td>40.4</td><td>23.6</td><td>10.7</td><td>23.5</td><td>17.5</td><td>31.8</td></tr><tr><td>AugMix</td><td>11.1±0.2</td><td>16.0±0.3</td><td>+5.9</td><td>9.8</td><td>27.8</td><td>13.4</td><td>5.9</td><td>30.3</td><td>18.0</td><td>8.3</td><td>12.1</td><td>15.5</td><td>19.2</td></tr><tr><td>PG</td><td>17.0±0.3</td><td>23.8±0.5</td><td>+6.8</td><td>9.0</td><td>30.1</td><td>21.6</td><td>12.8</td><td>35.4</td><td>20.6</td><td>8.8</td><td>21.5</td><td>19.3</td><td>59.5</td></tr></table>",
+        "bbox": [
+            176,
+            204,
+            821,
+            416
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/3346b943f627e8a5bf9f9be2b581459bec9a3ebf427ca63bd08176707829e35f.jpg",
+        "table_caption": [
+            "Table 2: Comparison of errors on ImageNet-C and ImageNet-C for several robust models: WSL (weakly supervised ResNeXt-101-32x8d [21, 22]), EN (EfficientNet-B0 [32]), NS (Noisy Student EN-B0 [37]), ViT-S (Transformer [7, 34]), ResNeSt (ResNeSt-50d, [41]), using pre-trained models provided with the respective papers. These models do not rely primarily on data augmentation to be robust, and there is no consistent degradation on ImageNet-C. This is additional evidence that the worse performance in Table 1 does not occur because ImageNet-C is harder generally. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>WSL</td><td>EN</td><td>NS</td><td>ViT-S</td><td>ResNeSt</td></tr><tr><td>IN-C Err</td><td>38.1</td><td>55.7</td><td>52.1</td><td>44.5</td><td>44.4</td></tr><tr><td>IN-CErr</td><td>39.2</td><td>53.4</td><td>52.2</td><td>41.1</td><td>41.6</td></tr></table>",
+        "bbox": [
+            315,
+            518,
+            679,
+            566
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "It may be surprising that Stylized-ImageNet also degrades, given that it is intuitively very different from every corruption. While our measure works for augmentations, it does not cover all possible methods that improve robustness, such as more complicated algorithms like Stylized-ImageNet. Stylized-ImageNet degradation may be due to other reasons. For instance, it primarily augments texture information and may help mostly with higher frequency corruptions, as can be seen by its improvement on single frequency noise and cocentric sine waves; ImageNet-C has fewer such corruptions than ImageNet-C. ImageNet-C is thus a useful tool for understanding the interaction between training procedure and corruption distribution, even beyond perceptual similarity. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            703
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nevertheless, note that it is the intuitively broader augmentation schemes, such as AutoAugment, AugMix, Stylized-ImageNet, and DeepAugment that generalize better to ImageNet-C. The importance of breadth has also been explored elsewhere[15, 38], but in the previous sections we have provided new quantitative evidence for why this may be true: broad augmentation schemes may be perceptually similar to more types of corruptions, and thus more likely to be perceptually similar to a new corruption. Moreover, AugMix and DeepAugment still improve over baseline on ImageNet-C, so there is reason to be optimistic that robustness to unknown corruptions is an achievable goal, as long as evaluation is treated carefully. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            838,
+            292,
+            854
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Societal Impact. Our method for finding dissimilar corruptions could in principle be used to adversarially attack computer vision systems, such as those in content moderation or self-driving cars. Moreover, our ultimate goal is to help improve robustness in computer vision, and such robust systems may be used in detrimentals ways, for example in autonomous weapons or surveillance. However, we expect better evaluation of robust models to have definite benefits as well. In the long run, such an understanding should help defend against adversarial attacks. Our tools could also be used to challenge purportedly robust systems that are actually dangerously unreliable, such as an autonomous driving system that is robust to common corruption benchmarks yet fails to be robust to a dissimilar but important corruption, e.g., maybe glare. For instance, is the model employing data augmentation that is perceptually similar to the corruptions being used to report good robustness? Is the set of validation corruptions sufficiently broad that we would expect reasonable generalization to an unseen corruption? If we generate a dissimilar set of corruptions using the procedure we develop here, does the model still perform well on the new corruptions? Quantitative ways to answer these questions may provide a means to verify the robust performance of a model before it encounters and potentially fails on a critical, previously unseen corruption. ",
+        "bbox": [
+            176,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            257
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Corruption robustness as a secondary learning task. We have provided evidence that data augmentation may not generalize well beyond a given corruption benchmark. To explore this further, consider an analogy to a regular learning problem. We may think of corruption robustness in the presence of data augmentation as a sort of secondary task layered on the primary classification task: the set of data augmentations is the training set, the set of corruptions is the test set, and the goal is to achieve invariance of the underlying primary task. In this language, the ‘datasets’ involved are quite small: ImageNet-C has only 15 corruption types, and several augmentation schemes composite only around 10 basic transforms. In this case, standard machine learning practice would dictate a training/validation/test set split; it is only the size and breadth of modern vision datasets that has allowed this to be neglected in certain cases recently. But the effective dataset size of a corruption robustness problem is tiny, so having a held-out test set seems necessary. To emphasize, this is not a test set of the underlying classification task, for which generalization has been studied by Recht et al. [23, 24]. Instead, it is a test set of corruption transforms themselves. This means there would be validation/test split of dissimilar transformations, both applied to the ImageNet validation set6. ",
+        "bbox": [
+            174,
+            272,
+            825,
+            465
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Real-world corruption robustness. Recently, Hendrycks et al. [15] and Taori et al. [33] study how performance on corruption transforms generalizes to real-world corruptions and come to conflicting conclusions. Though we do not study real-world corruptions, we have proposed a mechanism that may explain the conflict: performance will generalize between transforms and real-world corruptions if they are perceptually similar, but will likely not if they are dissimilar. Since Hendrycks et al. [15] and Taori et al. [33] draw on different real-world and synthetic corruptions, it may be that the perceptual similarity between datasets differs in the two analyses. This also suggests a way to find additional corruption transforms that correlate with real-world corruptions: transforms should be sought that have maximal perceptual similarity with real-world corruptions. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            604
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Generalization does occur. We have encountered two features of data augmentation that may explain why it can be such a powerful tool for corruption robustness, despite the issues discussed above. First, within a class of perceptually similar transforms, generalization does occur. This means each simple data augmentation may confer robustness to many complicated corruptions, as long as they share perceptual similarity. Second, dissimilar augmentations in an augmentation scheme often causes little to no loss in performance, as long as a similar augmentation is also present. We briefly study this in Appendix A by demonstrating that adding many dissimilar augmentations increases error much less than adding a few similar augmentations decreases it. These two features suggest broad augmentation schemes with many dissimilar augmentations may confer robustness to a large class of unknown corruptions. More generally, we think data augmentation is a promising direction of study for corruption robustness, as long as significant care is taken in evaluation. ",
+        "bbox": [
+            174,
+            618,
+            825,
+            770
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements and Funding Disclosure ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            789,
+            540,
+            806
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eric Mintun would like to thank Matthew Leavitt, Sho Yaida, and Achal Dave for discussions during the development of this work. Additionally, he would like to acknowledge the Facebook AI residency program for providing excellent training and support in AI research. The authors received no external funding and have no competing interests. ",
+        "bbox": [
+            174,
+            820,
+            825,
+            876
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Bruna, J. and Mallat, S. Invariant scattering convolution networks. IEEE transactions on pattern analysis and machine intelligence, 35(8):1872–1886, 2013.   \n[2] Cubuk, E. D., Zoph, B., Mané, D., Vasudevan, V., and Le, Q. V. AutoAugment: Learning augmentation strategies from data. In CVPR, 2019.   \n[3] Dao, T., Gu, A., Ratner, A. J., Smith, V., De Sa, C., and Ré, C. A kernel theory of modern data augmentation. Proceedings of machine learning research, 97:1528, 2019.   \n[4] Deng, J., Dong, W., Socher, R., Li, L.-J., Li, K., and Fei-Fei, L. ImageNet: A large-scale hierarchical image database. In CVPR, 2009.   \n[5] Ding, K., Ma, K., Wang, S., and Simoncelli, E. P. Image quality assessment: Unifying structure and texture similarity. IEEE transactions on pattern analysis and machine intelligence, 2020.   \n[6] Dodge, S. and Karam, L. A study and comparison of human and deep learning recognition performance under visual distortions. In ICCCN, 2017.   \n[7] 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 ICLR, 2021.   \n[8] Geirhos, R., Temme, C. R., Rauber, J., Schütt, H. H., Bethge, M., and Wichmann, F. A. Generalisation in humans and deep neural networks. In NeurIPS, 2018.   \n[9] Geirhos, R., Rubisch, P., Michaelis, C., Bethge, M., Wichmann, F. A., and Brendel, W. ImageNet-trained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness. In ICLR, 2019.   \n[10] Gladman, S. J. Filterpedia, 2016. URL https://github.com/FlexMonkey/Filterpedia.   \n[11] Goyal, P., Dollár, P., Girshick, R., Noordhuis, P., Wesolowski, L., Kyrola, A., Tulloch, A., Jia, Y., and He, K. Accurate, large minibatch SGD: Training ImageNet in 1 hour. arXiv preprint arXiv:1706.02677, 2017.   \n[12] He, K., Zhang, X., Ren, S., and Sun, J. Deep residual learning for image recognition. In CVPR, 2016.   \n[13] Hendrycks, D. and Dietterich, T. Benchmarking neural network robustness to common corruptions and perturbations. In ICLR, 2018.   \n[14] 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 ICLR, 2019.   \n[15] Hendrycks, D., Basart, S., Mu, N., Kadavath, S., Wang, F., Dorundo, E., Desai, R., Zhu, T., Parajuli, S., Guo, M., Song, D., Steinhardt, J., and Gilmer, J. The many faces of robustness: A critical analysis of out-of-distribution generalization. arXiv preprint arXiv:2006.16241, 2020.   \n[16] Huxtable, J. JH Labs Java Image Processing, 2006. URL http://www.jhlabs.com/ip/ filters/.   \n[17] Krizhevsky, A., Hinton, G., et al. Learning multiple layers of features from tiny images. 2009.   \n[18] Lee, J., Won, T., and Hong, K. Compounding the performance improvements of assembled techniques in a convolutional neural network. arXiv preprint arXiv:2001.06268, 2020.   \n[19] Liang, J., Hu, D., and Feng, J. Do we really need to access the source data? source hypothesis transfer for unsupervised domain adaptation. In International Conference on Machine Learning, pp. 6028–6039. PMLR, 2020.   \n[20] Lopes, R. G., Yin, D., Poole, B., Gilmer, J., and Cubuk, E. D. Improving robustness without sacrificing accuracy with Patch Gaussian augmentation. arXiv preprint arXiv:1906.02611, 2019.   \n[21] Mahajan, D., Girshick, R., Ramanathan, V., He, K., Paluri, M., Li, Y., Bharambe, A., and van der Maaten, L. Exploring the limits of weakly supervised pretraining. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 181–196, 2018.   \n[22] Orhan, A. E. Robustness properties of Facebook’s ResNeXt WSL models. arXiv preprint arXiv:1907.07640, 2019.   \n[23] Recht, B., Roelofs, R., Schmidt, L., and Shankar, V. Do CIFAR-10 classifiers generalize to CIFAR-10? arXiv preprint arXiv:1806.00451, 2018.   \n[24] Recht, B., Roelofs, R., Schmidt, L., and Shankar, V. Do ImageNet classifiers generalize to ImageNet? In ICML, 2019.   \n[25] Rusak, E., Schott, L., Zimmermann, R., Bitterwolf, J., Bringmann, O., Bethge, M., and Brendel, W. A simple way to make neural networks robust against diverse image corruptions. arXiv preprint arXiv:2001.06057, 2020.   \n[26] Schneider, S., Rusak, E., Eck, L., Bringmann, O., Brendel, W., and Bethge, M. Improving robustness against common corruptions by covariate shift adaptation. In NeurIPS, 2020.   \n[27] Shankar, V., Dave, A., Roelofs, R., Ramanan, D., Recht, B., and Schmidt, L. Do image classifiers generalize across time? arXiv preprint arXiv:1906.02168, 2019.   \n[28] Simard, P. Y., LeCun, Y. A., Denker, J. S., and Victorri, B. Transformation invariance in pattern recognition—tangent distance and tangent propagation. In Neural networks: tricks of the trade, pp. 239–274. Springer, 1998.   \n[29] Simonyan, K. and Zisserman, A. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   \n[30] Sun, Y., Wang, X., Liu, Z., Miller, J., Efros, A., and Hardt, M. Test-time training with selfsupervision for generalization under distribution shifts. In International Conference on Machine Learning, pp. 9229–9248. PMLR, 2020.   \n[31] Szegedy, C., Zaremba, W., Sutskever, I., Bruna, J., Erhan, D., Goodfellow, I., and Fergus, R. Intriguing properties of neural networks. In ICLR, 2014.   \n[32] Tan, M. and Le, Q. EfficientNet: Rethinking model scaling for convolutional neural networks. In ICML, 2019.   \n[33] Taori, R., Dave, A., Shankar, V., Carlini, N., Recht, B., and Schmidt, L. Measuring robustness to natural distribution shifts in image classification. In NeurIPS, 2020.   \n[34] Touvron, H., Cord, M., Douze, M., Massa, F., Sablayrolles, A., and Jégou, H. Training dataefficient image transformers & distillation through attention. arXiv preprint arXiv:2012.12877, 2020.   \n[35] Wang, D., Shelhamer, E., Liu, S., Olshausen, B., and Darrell, T. Tent: Fully test-time adaptation by entropy minimization. ICLR, 2021.   \n[36] Wu, S., Zhang, H. R., Valiant, G., and Ré, C. On the generalization effects of linear transformations in data augmentation. In ICML, 2020.   \n[37] Xie, Q., Luong, M.-T., Hovy, E., and Le, Q. V. Self-training with Noisy Student improves imagenet classification. In CVPR, 2020.   \n[38] Yin, D., Lopes, R. G., Shlens, J., Cubuk, E. D., and Gilmer, J. A Fourier perspective on model robustness in computer vision. In NeurIPS, 2019.   \n[39] Zagoruyko, S. and Komodakis, N. Wide residual networks. In BMVC, 2016.   \n[40] Zhang, H., Cisse, M., Dauphin, Y. N., and Lopez-Paz, D. mixup: Beyond empirical risk minimization. In ICLR, 2018.   \n[41] Zhang, H., Wu, C., Zhang, Z., Zhu, Y., Zhang, Z., Lin, H., Sun, Y., He, T., Muller, J., Manmatha, R., Li, M., and Smola, A. ResNeSt: Split-Attention Networks. arXiv preprint arXiv:2004.08955, 2020.   \n[42] Zhang, R., Isola, P., Efros, A. A., Shechtman, E., and Wang, O. The unreasonable effectiveness of deep features as a perceptual metric. In CVPR, 2018.   \n[43] Zilly, J., Zilly, H., Richter, O., Wattenhofer, R., Censi, A., and Frazzoli, E. The Frechet Distance of training and test distribution predicts the generalization gap. OpenReview preprint, 2019. URL https://openreview.net/forum?id $\\cdot ^ { = }$ SJgSflHKDr. ",
+        "bbox": [
+            171,
+            69,
+            830,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            71,
+            828,
+            916
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            90,
+            828,
+            223
+        ],
+        "page_idx": 12
+    }
+]

parse/train/gG4j9PybfwI/gG4j9PybfwI.md

@@ -0,0 +1,452 @@
+# Beyond Fine-Tuning: Transferring Behavior in Reinforcement Learning
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Designing agents that acquire knowledge autonomously and use it to solve new   
+2 tasks efficiently is an important challenge in reinforcement learning. Knowledge   
+3 acquired during an unsupervised pre-training phase is often transferred by fine  
+4 tuning neural network weights once rewards are exposed, as is common practice   
+5 in supervised domains. Given the nature of the reinforcement learning problem,   
+6 we argue that standard fine-tuning strategies alone are not enough for efficient   
+7 transfer in challenging domains. We introduce Behavior Transfer (BT), a technique   
+8 that leverages pre-trained policies for exploration and that is complementary to   
+9 transferring neural network weights. Our experiments show that, when combined   
+10 with large-scale pre-training in the absence of rewards, existing intrinsic motivation   
+11 objectives can lead to the emergence of complex behaviors. These pre-trained   
+12 policies can then be leveraged by BT to discover better solutions than without   
+13 pre-training, and combining BT with standard fine-tuning strategies results in   
+14 additional benefits. The largest gains are generally observed in domains requiring   
+15 structured exploration, including settings where the behavior of the pre-trained   
+16 policies is misaligned with the downstream task.
+
+# 17 1 Introduction
+
+18 Transfer in deep learning is often performed through parameter initialization followed by fine-tuning,   
+19 a technique that allows to leverage the power of deep networks in domains where labelled data   
+20 is scarce [60, 16, 61, 22, 15]. This builds on the intuition that the pre-trained model will map   
+21 inputs to a feature space where the downstream task is easy to perform. When combined with   
+22 methods that can leverage massive amounts of unlabelled data for pre-training, this transfer strategy   
+23 has led to unprecedented results in domains like computer vision [31, 30] and natural language   
+24 processing [15, 50]. The success of these approaches has led to an ever-growing interest in developing   
+25 techniques for pre-training large scale models on unlabelled data [9, 13, 24].   
+26 In the reinforcement learning (RL) context, unsupervised methods that learn in the absence of reward   
+27 have also garnered much research attention [23, 21, 46, 19, 29]. The benefits of unsupervised pre  
+28 training are typically evaluated by their ability to enable efficient transfer to previously unseen reward   
+29 functions [28]. In spite of their different approaches to unsupervised RL, most of the top-performing   
+30 methods in this setting transfer knowledge through neural network weights. Such approaches deal   
+31 with the data inefficiency associated to training neural networks with gradient descent, similarly to   
+32 what is done in supervised learning, e.g. by pre-training encoders that extract representations from   
+33 observations [59]. However, RL introduces a challenge that is not present in supervised learning: the   
+34 agent is responsible for collecting the right data to learn from. This introduces a second source of   
+35 inefficiency from which transfer approaches can also suffer if they rely on unstructured exploration   
+36 strategies after pre-training, as these can lead to exponentially larger data requirements in complex   
+37 downstream environments [45, 44]. To address this problem, one could consider fine-tuning policies   
+38 that produce meaningful behavior [43, 52], but this approach quickly disregards the pre-trained   
+39 behavior when learning in the downstream task due to catastrophic forgetting.   
+40 In this work, we explicitly separate the transfer of behaviour and weights. We propose to make   
+41 use of the pre-trained behaviour itself (i.e., the pre-trained policy mapping from observations to   
+42 actions) in contrast to pre-trained neural network weights for further fine-tuning. While pre-trained   
+43 behavior has been used before for exploitation [5, 56, 2, 3], our approach employs pre-trained policies   
+44 to aid with exploration as well to collect experience that can be leveraged via off-policy learning.   
+45 This strategy accelerates learning, as the agent is exposed to potentially useful experience earlier in   
+46 training, without compromising the quality of the discovered solution when the pre-trained behavior   
+47 is not aligned with the downstream task. We expose the pre-trained behaviour to the downstream   
+48 agent in two ways: firstly, as an extra exploratory strategy that, when randomly activated, persists for   
+49 a number of steps, and secondly as an additional pseudo-action for the learned value function where   
+50 the agent may elect to defer action selection to the pre-trained policy instead of choosing itself. We   
+51 call this approach Behavior Transfer (BT).   
+52 Defining unsupervised RL objectives remains an open problem, and solutions are generally influenced   
+53 by how the acquired knowledge will be used for solving downstream tasks. Instead of proposing yet   
+54 another objective for unsupervised pre-training, we turn to existing techniques for training policies in   
+55 the absence of reward and make our choice based on two general requirements. First, the objective   
+56 should scale gracefully with increased compute and data. This has been key for the success of   
+57 self-supervised approaches in other domains [9, 35], and we argue that it is an important property for   
+58 unsupervised RL as well. Second, the pre-training stage should return a policy that produces complex   
+59 behavior that may be leveraged in a subsequent transfer stage. The Never Give Up (NGU) [48]   
+60 intrinsic reward meets both requirements, and our experiments show that large-scale pre-training with   
+61 this objective leads to state of the art scores in the reward-free Atari benchmark.   
+62 Figure 1 exemplifies our main findings. We pre-train behaviour using the intrinsic NGU reward during   
+63 a long unsupervised phase without rewards. This gives rise to exploratory behaviors that seek to visit   
+64 many different states throughout an episode, and we then compare different strategies for leveraging   
+65 the acquired knowledge once rewards are reinstated. While fine-tuning the pre-trained weights   
+66 enables faster learning, the exploratory behavior of the pre-trained policy is quickly disregarded as it   
+67 is exposed to rewards. On the other hand, Behavior Transfer (BT) does not modify the pre-trained   
+68 policy while learning in the new task and is able to achieve higher end scores thanks to better   
+69 exploration. These two strategies are not mutually exclusive, and BT also benefits from the faster   
+70 convergence provided by initializing neural networks with pre-trained weights when these encode   
+71 useful information for solving the downstream task.   
+72 Our contributions can be summarized as follows. (1) We propose Behavior Transfer (BT), a technique   
+73 that leverages pre-trained policies for exploration by treating them as black boxes that are not modified   
+74 during learning on the downstream task. BT uses the pre-trained policy to collect experience in   
+75 two ways, namely randomly-triggered temporally-extended exploration and one-step calls based on   
+76 value estimates. (2) Our experiments show that large-scale unsupervised pre-training with existing   
+77 intrinsic rewards can produce meaningful behavior, achieving state of the art results in the reward-free   
+78 Atari benchmark. These results suggest that scale is key for unsupervised RL, akin to what has been   
+79 observed in supervised settings. (3) We provide extensive empirical evidence demonstrating the   
+80 benefits of leveraging pre-trained behavior via BT. Our approach obtains the largest gains in hard   
+81 exploration games, where it almost doubles the median human normalized score achieved by our   
+82 strongest baseline. Furthermore, we show that BT is able to leverage a single task-agnostic policy   
+83 to solve multiple tasks in the same environment and to achieve high performance even when the   
+84 pre-trained policies are misaligned with the task being solved. (4) BT brings benefits to the table   
+85 that are complementary to those provided by reusing pre-trained neural network weights, and we   
+86 empirically show that combining these two strategies can result in larger gains.
+
+![](images/696568b2c84f51d1ef7c367946f1a4c3d2eebbbcb736aedca9ae66aae814bfa2.jpg)  
+Figure 1: Comparison of transfer strategies on Montezuma’s Revenge and Defender after pre-training a policy with NGU [48] in the absence of reward. The benefits of our proposed approach to leverage pre-trained behavior for exploration, Behavior Transfer (BT), are complementary to the gains provided by pre-trained weight initialization followed by fine-tuning.
+
+# 87 2 Preliminaries
+
+88 The interaction between the agent and the environment is modelled as a Markov Decission Pro  
+89 cess (MDP) [49]. An MDP is defined by the tuple $( S , A , P , d _ { 0 } , R , \gamma )$ where $s$ and $\mathcal { A }$ are the state   
+90 and action spaces, $P ( s ^ { \prime } | s , a )$ is the probability of transitioning from state $s$ to $s ^ { \prime }$ after taking action $a$   
+91 $d _ { 0 } ( s )$ is the probability distribution over initial states, $R : S \times \mathcal { A } \times \mathcal { S }  \mathbb { R }$ is the reward function,   
+92 and retu $\gamma \in [ 0 , 1 )$ $\begin{array} { r } { \dot { G } _ { t } = \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } R _ { t } } \end{array}$ unt fact, where $R _ { t } = r \hat { ( } S _ { t } , A _ { t } , S _ { t + 1 } )$ a policy . A prin $\pi ( a | s )$ that maximizes the expected way to address this problem   
+94 is to use methods that compute action-value functions, $Q ^ { \pi } ( \bar { s } , a ) \overset { - } { = } \mathbb { E } _ { \pi } \left[ G _ { t } \vert S _ { t } = s , A _ { t } = a \right]$ , where   
+95 $\mathbb { E } _ { \pi } [ \cdot ]$ denotes expectation over transitions induced by $\pi$ [49].   
+96 We consider a setting where the agent is allowed to first learn within an MDP without rewards,   
+97 $\boldsymbol { \mathcal { M } } ^ { R } = ( \boldsymbol { \mathcal { S } } , \boldsymbol { \mathcal { A } } , P , d _ { 0 } )$ , for a long period of time. The knowledge acquired during the reward-free   
+98 stage is later leveraged when maximizing reward in new MDPs that share the same underlying   
+99 dynamics but have different reward functions, $\mathcal { M } _ { i } = ( S , A , P , d _ { 0 } , R _ { i } , \gamma _ { i } )$ . Interactions between the   
+100 agent and the environment are often assumed to incur a cost, but we will consider this cost to be   
+101 relevant only for transitions with reward [28]. Even if the cost of unsupervised pre-training becomes   
+102 non-negligible, it can be amortized when the acquired task-agnostic knowledge is leveraged to solve   
+103 multiple tasks efficiently [15, 9]. Indeed, we would expect this transfer setting to become more   
+104 relevant as the community moves towards more complex environments, where one may want to   
+105 train agents to maximize multiple reward functions under constant dynamics. In the limit, one could   
+106 consider the real world: it has constant or slowly changing dynamics, and humans are able to leverage   
+107 previously acquired skills to quickly master new tasks.
+
+# 108 3 Behavior Transfer
+
+109 Transfer in supervised domains often exploits the fact that related tasks might be solved using similar   
+110 representations. This practice deals with the data inefficiency of training large neural networks   
+111 with stochastic gradient descent. However, there is an additional source of data inefficiency when   
+112 training RL agents: unstructured exploration. Fine-tuning a pre-trained exploratory policy arises as   
+113 a potential strategy for overcoming this problem, as the agent will observe rich experience much   
+114 earlier in training than when initializing the policy randomly, but this approach suffers from important   
+115 limitations. Learning in the downstream task can lead to catastrophically forgetting the pre-trained   
+116 policy, thus prematurely disregarding its exploratory behavior. Moreover, the same neural network   
+117 architecture needs to be used for both the pre-trained and the downstream policies, which in practice   
+118 also imposes a limitation on the type of RL methods that can be employed in the adaptation stage (for   
+119 instance, if the pre-trained policy was trained using a policy-based method, it might not be possible   
+120 to fine-tune it using a value-based approach).   
+121 Let us assume that we have access to a pre-trained policy that exhibits exploratory behavior, and   
+122 defer the discussion on how to train this policy to Section 4. Following such a policy might bring   
+123 the agent to states that are unlikely to be visited with unstructured exploration techniques such as   
+124 $\epsilon$ -greedy [55]. This property has the potential of accelerating learning even when the behavior of   
+125 the pre-trained policy is not aligned with the downstream task, as it will effectively shorten the   
+126 path between otherwise distant states [41]. Leveraging pre-trained policies for exploration differs   
+127 from other approaches in the literature that use such policies directly for exploitation, e.g. via   
+128 zero-shot transfer [19], methods that define a higher-level policy that alternates between the given   
+129 policies [5, 56], or within the framework of generalized policy updates [4]. Exploring with pre-trained   
+130 policies can accelerate convergence by providing useful experience to the agent, which is possible   
+131 even when the pre-training and downstream tasks are misaligned. However, strategies that directly   
+132 use the pre-trained policies for exploitation may result in sub-optimal solutions in such scenario [2].   
+133 We propose to leverage the behavior of pre-trained policies during transfer to aid with exploration. An   
+134 explicit distinction between behavior and representation is made by considering pre-trained policies as   
+135 black boxes that take observations and return actions. This strategy is agnostic to how the pre-trained   
+136 behavior is encoded and is not restricted to learned policies. We rely on off-policy learning methods   
+137 during transfer to leverage the behavior of a pre-trained policy $\bar { \pi _ { p } ( a | s ) }$ . We keep $\pi _ { p }$ fixed during   
+138 transfer, which prevents catastrophic forgetting of the original behavior when it is parameterized by a   
+139 neural network (i.e., we instantiate and train a new policy with its own set of parameters). We propose   
+140 Behavior Transfer (BT), which leverages two complementary strategies to achieve this. Since BT   
+141 is agnostic to the method used to pre-train policies, $B T ( \pi _ { p } )$ refers to behavior being transferred   
+142 from policy $\pi _ { p }$ . We formalize BT in the context of value-based Q-learning agents, although similar   
+143 derivations are in principle possible for alternative off-policy learning methods. Pseudo-code for BT   
+144 is provided in Algorithm 1.   
+145 Temporally-extended exploration. We draw inspiration from Lévy flights [57], a class of ecological   
+146 models for animal foraging, where a fixed direction is followed for a duration sampled from a   
+147 heavy-tailed distribution. This principle was implemented in the context of exploration in RL by   
+148 $\epsilon z$ -greedy [14], which encodes the notion of direction in the environment via exploration options that   
+149 repeat the same action throughout the entire flight. Since $\pi _ { p }$ is more likely to encode a meaningful   
+150 notion of direction in complex environments than action repeats, we propose a variant of $\epsilon z$ -greedy   
+151 where $\pi _ { p }$ is used as the exploration option. An exploratory flight might be started at any step with   
+152 some probability. The duration for the flight is sampled from a heavy-tailed distribution (Zeta with   
+153 $\mu = 2$ in all our experiments), and control is handed over to $\pi _ { p }$ during the complete flight. When not   
+154 in a flight, actions are sampled from the behavior policy obtained while maximizing the task reward   
+155 (e.g. an $\epsilon$ -greedy derived from the estimated Q values).   
+156 Extra action. The previous approach switches to $\pi _ { p }$ during experience collection blindly, and we   
+157 now consider an alternative strategy for triggering these switches based on value. This can be easily   
+158 implemented through an extra action which samples an action from $\pi _ { p }$ , which also allows the agent to   
+159 use the pre-trained policy at test time if deemed beneficial. More formally, this amounts to training a   
+160 policy over an expanded action set $\mathcal { A } ^ { + } = \mathcal { A } \cup \{ a _ { + } \}$ , where $a _ { + }$ is resolved by sampling an action from   
+161 $\pi _ { p }$ , $a ^ { \prime } \sim \pi _ { p } ( s )$ (with $a ^ { \prime } \in { \mathcal { A } }$ ). The additional action can be seen as an option that can be initiated   
+162 from any state and always terminates after a single step. Note that selecting the option will lead to   
+163 the same outcome as if the agent had selected $a ^ { \prime }$ as a primitive action, and we take advantage of this   
+164 observation by using the return of following the option as target to fit both $Q ( s , \pi _ { p } ( s ) )$ and $Q ( s , a ^ { \prime } )$ .   
+165 Intuitively, this approach induces a bias that favours actions selected by $\pi _ { p }$ , accelerating the collection   
+166 of rewarding transitions when the pre-trained policy is somewhat aligned with the downstream task.   
+167 Otherwise, the agent can learn to ignore $\pi _ { p }$ as training progresses by selecting other actions.
+
+# Algorithm 1: Experience collection pseudo-code for BT
+
+Input: Action set, $\mathcal { A }$ ; additional action, $a _ { + }$ ; extended action set, $\mathcal { A } ^ { + } = \mathcal { A } \cup \{ a _ { + } \}$ ; pre-trained policy, $\pi _ { p }$ ; Q-value estimate for the current policy, $Q ^ { \pi } ( s , a ) \forall a \in A ^ { + }$ ; probability of taking an exploratory action, $\epsilon$ ; probability of starting a flight, $\epsilon _ { \mathrm { l e v y } }$ ; flight length distribution, $\mathcal { D } ( \mathbb { N } )$   
+while True do $n \gets 0$ // flight length while episode not ended do Observe state $s$ if $n = = 0$ and random $) \le \epsilon _ { l e v y }$ then $n \sim \mathcal { D } ( \mathbb { N } )$ // sample flight length if $n > 0$ then $\begin{array} { l } { n  n - 1 } \\ { a \sim \pi _ { p } ( s ) } \end{array}$ else if random $) \leq \epsilon$ then $a \sim \operatorname { U n i f o r m } ( \mathcal { A } ^ { + } )$ else $a \gets \arg \operatorname* { m a x } _ { a ^ { \prime } \in \mathcal { A } ^ { + } } [ Q ^ { \pi } ( s , a ^ { \prime } ) ]$ if $a = = a _ { + }$ then $a \sim \pi _ { p } ( s )$ end Take action $a$ end   
+end
+
+169 It is a common practice to derive objectives for proxy tasks in order to drive learning in the absence   
+170 of reward functions, and there exists a plethora of different approaches in the literature. Model-based   
+171 approaches can learn world models from unsupervised interaction [26]. However, the diversity of   
+172 the training data will impact the accuracy of the model [53] and deploying this type of approach   
+173 in visually complex domains like Atari remains an open problem [27]. Unsupervised RL has also   
+174 been explored through the lens of empowerment [51, 42], which studies agents that aim to discover   
+175 intrinsic options [23, 19]. While these options can be leveraged by hierarchical agents [21] or   
+176 integrated within the universal successor features framework [2, 3, 8, 28], their potential lack of   
+177 coverage generally limits their applicability to complex downstream tasks [12]. An alternative   
+178 objective is that of exploring the environment by finding policies that induce maximally entropic state   
+179 distributions [29, 39], although this might become extremely inefficient in high-dimensional state   
+180 spaces without proper priors [40, 59].   
+181 Recall that our goal is to devise a pre-training objective that can help reduce the amount of interaction   
+182 needed by the agent to collect relevant experience when learning in a downstream task. We argue that   
+183 such objective needs to meet two requirements. First, as suggested by results in other domains [9, 35],   
+184 it should scale gracefully as the amount of compute and experience used for pre-training are increased.   
+185 This contrasts with the training regimes used in most unsupervised RL approaches, which use a   
+186 relatively small amount of experience [28, 40, 59] when compared to distributed agents that do make   
+187 use of rewards [33, 18, 36]. Second, it must encourage the emergence of complex behaviors such as   
+188 navigation or manipulation skills. It has been argued that exploring the environment efficiently will   
+189 serve as a proxy for developing such behaviors [37], and exploration bonuses have been shown to   
+190 produce meaningful behavior in the absence of reward [46, 10]. However, many exploration bonuses   
+191 vanish over the course of training and thus may not be well-suited for a long unsupervised pre-training   
+192 phase. It can be shown that many intrinsic rewards aim at maximizing the entropy of all states visited   
+193 during training, and so the final policy does not necessarily exhibit exploratory behavior [39].   
+194 We propose to use Never Give Up (NGU) [48] as a means for training exploratory policies in an   
+195 unsupervised setting. The NGU intrinsic reward proposes a curiosity-driven approach for training   
+196 persistent exploratory policies which combines per-episode and life-long novelty. The per-episode   
+197 novelty, $r _ { t } ^ { \mathrm { e p i s o d i c } }$ , rapidly vanishes over the course of an episode, and it is designed to encourage self  
+198 avoiding trajectories. It is computed by comparing a representation of the current observation, $f ( s _ { t } )$ ,   
+199 to those of all the observations visited in the current episode, $M = \{ f ( s _ { 0 } ) , f ( s _ { 1 } ) , \dotsc , f ( s _ { t - 1 } ) \}$ ,   
+200 where $f : \mathcal { S }  \mathbb { R } ^ { p }$ is an embedding function trained using a self-supervised inverse dynamics   
+201 model [46]. Such a mapping concentrates on the controllable aspects of the environment, ignoring   
+202 all the variability present in the observation that is not affected by the action taken by the agent.   
+203 The life-long novelty, $\alpha _ { t }$ , slowly vanishes throughout training, and it is computed by using Random   
+204 Network Distillation (RND) [11]. With this, the intrinsic reward $r _ { t } ^ { \mathrm { { N G U } } }$ is defined as follows:
+
+$$
+r _ { t } ^ { \mathrm { N G U } } = r _ { t } ^ { \mathrm { { e p i s o d i c } } } \cdot \operatorname* { m i n } \left\{ \operatorname* { m a x } \left\{ \alpha _ { t } , 1 \right\} , L \right\} , \mathrm { ~ w i t h } r _ { t } ^ { \mathrm { e p i s o d i c } } = \frac { 1 } { \sqrt { \sum _ { f ( s _ { t } ) \in N _ { k } } K ( f ( s _ { t } ) , f ( s _ { i } ) ) + c ^ { 2 } } } .
+$$
+
+205 where $L$ is a fixed maximum reward scaling, $N _ { k }$ is the set containing the $k$ -nearest neighbors of $f ( s _ { t } )$   
+206 in $M$ , $c$ is a constant and $K : \mathbb { R } ^ { p } \times \mathbb { R } ^ { p } \to \mathbb { R } ^ { + }$ is a kernel function satisfying $K ( x , { \bar { x } } ) = 1$ (which   
+207 can be thought of as approximating pseudo-counts [48]). The episodic component of the reward   
+208 in Equation 1 is reset by emptying $M$ with each episode, thus the NGU reward does not vanish   
+209 throughout the training process. This makes it suitable for driving learning in task-agnostic settings.   
+210 Further details on NGU are reported in the supplementary material.
+
+# 211 5 Experiments
+
+212 Agents are evaluated in the Atari suite [7], a benchmark that presents a variety of challenges and that   
+213 is a common test ground for RL agents with unsupervised pre-training [28, 40, 52]. Experiments are   
+214 run using the distributed R2D2 agent [36] with 256 CPU actors and a single GPU learner. Policies   
+215 use the same Q-Network architecture as Agent57 [47], which is composed by a convolutional torso   
+216 followed by an LSTM [32] and a dueling head [58]. Hyperparameters and a detailed description of   
+217 the full distributed setting are provided in the supplementary material. All reported results are the   
+218 average over three random seeds.   
+219 Reward-free learning. The amount of task reward collected by unsupervised policies is often   
+220 used as a proxy to measure their quality [19]. While the actual utility of these policies will not   
+221 be revealed until they are leveraged for transfer, this proxy lets us evaluate whether the discovered   
+222 behavior changes as longer pre-training budgets are allowed. We compare unsupervised NGU policies   
+223 against VISR [28] and APT [40], which utilize a small amount of supervised interaction to adapt   
+224 the pre-trained policies. We also consider two additional unsupervised baselines: $( i )$ a constant   
+225 positive reward at each timestep that favours long episodes, which correlate with high scores in some   
+226 games [10], and (ii) RND [11], which rewards life-long novelty. Note that the RND reward vanishes,   
+227 but we include it in our analysis because it was previously used by Burda et al. [10] in this setting   
+228 and implementation choices such as reward normalization may prevent it from fading in practice.   
+229 Figure 2 (left) shows how the zero-shot transfer performance of unsupervised policies evolves during   
+230 a long pre-training phase. NGU reaches the highest scores, but both NGU and RND eventually   
+231 outperform VISR and APT even though these used supervised interaction. In Table 2 of Appendix   
+232 C we show that unsupervised NGU policies largely outperform several other baselines using the   
+233 standard pre-training and adaptation setting. These results highlight the importance of large-scale   
+234 unsupervised pre-training in RL, similarly to the trend observed in supervised domains [9].
+
+![](images/693f32859ff6d9b0ac39d33ab71c1a54485c1fe8c8c24525070d8a48b2d7618d.jpg)  
+Figure 2: Performance as a function of the pre-training budget. $@ N$ represents the number of frames with reward utilized for transfer. (Left) Median human normalized score across the 57 games in the Atari suite. We observe the emergence of useful behavior when optimizing an intrinsic reward during a long unsupervised pre-training of 16B frames, which contrasts with the shorter pre-training of 1B frames in previous works [28, 40]. (Right) Scores in the games of Montezuma’s Revenge (sparse rewards) and Pong (dense reward), before and after transfer, as a function of the pre-training budget. A longer pre-training benefits transfer in hard exploration games even if the zero-shot transfer score of the unsupervised policies does not increase.
+
+Transfer setting. Transfer approaches are typically evaluated in the Atari benchmark with a budget of 100k RL interactions with reward (400k frames), but we propose to allow a longer adaptation phase. Randomly initialized networks tend to overfit in these very low data regimes without strong regularization [38], and we are interested in studying the impact of leveraging behavior both in isolation and combined with transfer via pre-trained weights. Moreover, since the pre-trained policies are already competent in the downstream tasks, $1 0 0 \mathrm { k }$ interactions are exhausted after few episodes and may be insufficient for improving performance. For these reasons, we provide results with up to 1.25B RL steps of supervised interaction (5B frames). This allows evaluating both convergence speed and asymptotic performance, while still being a relatively small budget for these distributed agents with hundreds of actors [47].
+
+Transfer via behavior. We start by studying the impact of leveraging behavior in isolation, i.e. without transferring pre-trained weights, when learning in downstream tasks. We compare BT against two baselines that do not use pre-trained behavior, namely the standard R2D2 agent [36] that uses $\epsilon$ -greedy policies for exploration [55], as well as a variant of R2D2 with $\epsilon z$ -greedy exploration [14]. Figure 3 shows that BT is superior to both baselines for any amount of environment interaction with rewards, converging faster early in training and also obtaining higher asymptotic performance. These results also demonstrate the generality of the proposed approach, as it is able to benefit from both RND and NGU policies. Note that BT performs particularly well in the set of six hard exploration games1 defined by Bellemare et al. [6], which is aligned with our intuition that reusing behavior helps overcoming the inefficiency associated to unstructured exploration. Figure 2 (right) confirms that a long pre-training phase is especially important in hard exploration games such as Montezuma’s Revenge, even it they do not translate into higher zero-shot transfer scores, as it produces more exploratory behavior. On the other hand, the performance after transfer is independent of the amount of pre-training in dense reward games like Pong, where unstructured exploration is enough to reach optimal scores.
+
+![](images/7d402b37236621f24b6311f0a942112738113dc64eef0e4d23aa624852764151.jpg)  
+Figure 3: Median human normalized scores for R2D2-based agents trained from scratch. (Left) Full Atari suite. (Right) Subset of hard exploration games.
+
+![](images/985bc0ee229912f07e0229f480c5d0bf49fcef58c9fea4c4c5d8bc5084e081c9.jpg)  
+Figure 4: Usage of the extra action in $\mathrm { B T } ( \pi _ { \mathrm { N G U } } )$ , computed as the fraction of steps within an episode in which it is selected by the agent. The usage peaks early in training and slowly decreases afterwards as the new policy becomes stronger at the task.
+
+259 Ablation studies. In order to gain insight on each of the components in BT, we run experiments   
+260 on a subset of 12 games2 requiring different amounts of exploration and featuring both dense and   
+261 sparse rewards. $\mathbf { B T } ( \pi _ { \mathrm { N G U } } )$ achieves a median score of 368 in this subset, which compares favorably   
+262 to the 196 median score of R2D2 with $\epsilon$ -greedy exploration. Removing either the extra action or   
+263 the temporally-extended exploration reduces the median score of $\mathbf { B T } ( \pi _ { \mathrm { N G U } } )$ to 224. These results   
+264 suggest that the gains provided by both strategies are complementary, and both are responsible for the   
+265 strong performance of BT. To provide further insight about the benefits of BT, Figure 4 reports the   
+266 fraction of steps per episode in which the extra action is selected by the greedy policy. It hints at the   
+267 emergence of a schedule over the usage of the pre-trained policy, which increases early in training   
+268 and decays afterwards. We hypothesize that this is due to the fact that the unsupervised policies   
+269 obtain large episodic returns, but their behavior is suboptimal when maximizing discounted rewards.   
+270 These policies take many exploratory actions in between rewards, and so the agent eventually figures   
+271 out more efficient strategies for reaching rewarding states by using primitive actions.
+
+Transfer to multiple tasks. An appealing property of task-agnostic knowledge is that it can be leveraged to solve multiple tasks. In the RL setting, this can be evaluated by leveraging a single task-agnostic policy for solving multiple tasks (i.e. reward functions) in the same environment. We evaluate whether the unsupervised NGU policies can be useful beyond the standard Atari tasks by creating two alternative versions of Ms Pacman and Hero with different levels of difficulty. The goal in the modified version of Ms Pacman is to eat vulnerable ghosts, with pac-dots giving 0 (easy version) or $- 1 0$ (hard version) points. In the modified version of Hero, saving miners gives a fixed return of 1000 points and dynamiting walls gives either 0 (easy version) or $- 3 0 0$ (hard version) points. The rest of rewards are removed, e.g. eating fruit in Ms Pacman or the bonus for unused power units in Hero. Note that even in the easy version of the games exploration is harder than in their original counterparts, as there are no small rewards guiding the agent towards its goals. Exploration is even more challenging in the hard version of the games, as the intermediate rewards work as a deceptive signal that takes the agent away from its actual goal. In this case, finding rewarding behaviors requires a stronger commitment to an exploration strategy. Unsupervised NGU policies often achieve very low or even negative rewards in this setting, which contrasts with the strong performance they showed when evaluated under the standard game reward. Figure 5 shows that leveraging the behavior of pre-trained exploration policies provides important gains even in this adversarial scenario. These results suggest that the strong performance observed under the standard game rewards is not due to an
+
+![](images/b2e9bc9d03e347e12efc286b6a57b2532360ce7edf0ad56c7d736b2ec11175b8.jpg)  
+Figure 5: Scores in Atari games with modified reward functions. We train a single task-agnostic policy per environment, and leverage it to solve three different tasks: the standard game reward, a task with sparse rewards (easy), and a variant of the same task with deceptive rewards (hard).
+
+90 alignment between the NGU reward and the game goals, but due to an efficient usage of pre-trained   
+1 exploration policies.   
+292 Combining pre-trained behavior and weights. Our last batch of experiments focuses on studying   
+293 transfer via pre-trained weights and its compatibility with BT. Policies are composed of a convo  
+294 lutional torso, an LSTM, and a dueling head. We consider two initialization strategies: a partial   
+295 initialization approach that loads the torso and the LSTM, but initializes the head randomly; and a   
+296 full initialization scheme where all weights are loaded. The former can be understood as transferring   
+297 learned representations [59], but deferring exploration to a random policy. On the other hand, the   
+298 full initialization approach can be seen as directly transferring the policy and is usually referred to as   
+299 fine-tuning the pre-trained policy [43, 40, 52]. Note that these approaches only change how weights   
+300 are initialized before training. As in previous experiments, all parameters in the new policy are trained   
+301 and $\pi _ { p }$ is kept fixed when using BT. Figure 6 (top) compares agents with and without BT for different   
+302 amounts of transfer via weights on the Atari benchmark. Loading pre-trained weights results in faster   
+303 learning early in training, both with and without BT. The largest gains are observed in dense reward   
+304 games, which translates into higher median scores across the full suite because most games belong   
+305 to this category. Weights alone are not enough in hard exploration games, where leveraging the   
+306 pre-trained policy via BT provides clear benefits. Perhaps surprisingly, we observe that transferring   
+307 representations outperforms fine-tuning the pre-trained policy, and we hypothesize that the former   
+308 is more robust to misalignments between the pre-trained policy and the downstream task. This   
+309 intuition is further supported by the experiments on games with modified reward functions reported   
+310 in Figure 6 (middle & bottom), where the faster learning provided by pre-trained weights often comes   
+311 at the cost of lower end scores. On the other hand, BT is crucial in tasks with sparse and deceptive   
+12 rewards and also benefits from pre-trained weights in tasks where positive transfer is observed.
+
+# 6 Related work
+
+314 Our work uses the experimental methodology presented by Hansen et al. [28]. Whereas that work only   
+315 considered a fast, simplified adaptation process that limited the final performance on the downstream   
+316 task, we focus on the more general case of using a previously trained policy to aid in solving the   
+317 full RL problem. Hansen et al. [28] use successor features to identify which of the pre-trained tasks   
+318 best matches the true reward structure, which has previously been shown to work well for multi-task   
+319 transfer [3]. Bagot et al. [1] augments an agent with the ability to utilize another policy, which is   
+320 learned in tandem based on an intrinsic reward function. This promising direction is complementary   
+321 to our work, as it handles the case wherein there is no unsupervised pre-training phase.   
+322 Gupta et al. [25] provides an alternative method to meta-learn a solver for reinforcement learning prob  
+323 lems from unsupervised reward functions. This method utilizes gradient-based meta-learning [20],   
+324 which makes the adaptation process standard reinforcement learning updates. This means that even if   
+325 the downstream reward is far outside of the training distribution, final performance would not neces  
+326 sarily be affected. However, these methods are hard to scale to the larger networks considered here,   
+327 and followup work [34] changed to memory-based meta-learning [17] which relies on information   
+328 about rewards staying in the recurrent state. This makes it unsuitable to the sort of hard exploration   
+329 problem our method excels at. Recent work has shown success in transferring representations learned   
+330 in an unsupervised setting to reinforcement learning tasks [54]. Our representation transfer experi  
+331 ments suggest that this might handicap final performance, but the possibility also exists that different   
+332 unsupervised objectives should be used for representation transfer and policy transfer.
+
+![](images/789522c1b91b64812aefceb54c6d2e5dabd3c5fb5585eb5b04e66c0ba732af86.jpg)  
+Figure 6: Performance of R2D2-based agents with different amounts of transfer via weights. Policies are composed of a CNN encoder followed by an LSTM and a dueling head. We compare training from scratch, loading all weights (Full $\pi _ { \mathrm { N G U } }$ init) or all weights except those in the dueling head (Partial $\pi _ { \mathrm { { N G U } } }$ init). (Top) Median human normalized scores (HNS) in the full Atari suite (left) and the subset of hard exploration games (right). (Middle & Bottom) Games with modified reward functions as in Figure 5.
+
+# 7 Discussion
+
+We studied the problem of transferring pre-trained behavior for exploration in reinforcement learning, an approach that is complementary to the common practice of transferring neural network weights. Our proposed approach, Behavior Transfer (BT), relies on the pre-trained policy for collecting experience in two different ways: (i) through temporally-extended exploration, which can be triggered with some probability at any step, and $( i i )$ via one-step calls to the pre-trained policy based on value estimates. BT results in strong transfer performance when combined with exploratory policies pretrained in the absence of reward, with the most important gains being observed in hard exploration tasks. These benefits are not due to an alignment between our pre-training and downstream tasks, as we also observed positive transfer in games where the pre-trained policy obtained low scores. In order to provide further evidence for this claim, we designed alternative tasks for Atari games involving hard exploration and deceptive rewards. Our transfer strategy outperformed all considered baselines in these settings, even when the pre-trained policy obtained very low or even negative scores, demonstrating the generality of the method. Besides disambiguating the role of the alignment between pre-training and downstream tasks, these experiments demonstrate the utility of a single task-agnostic policy for solving multiple tasks in the same environment. Finally, we also demonstrated that BT can be combined with transfer via neural network weights to provide further gains.
+
+350 Our experimental results highlight the importance of scale when training RL agents in reward-free   
+351 settings, which is one of the key factors behind the recent success of unsupervised approaches in other   
+352 domains. This contrasts with the small budgets considered for reward-free RL in previous works and   
+353 motivates further research in unsupervised RL approaches that scale with increased data and compute.   
+354 We argue that scale is one of the missing components in reward-free RL, and it will be a necessary   
+355 condition to unfold its full potential. Beyond improving the unsupervised learning phase, we are also   
+356 excited about the possibilities unlocked by BT and that are not possible when transferring knowledge   
+357 through weights, such as leveraging multiple pre-trained policies and deploying BT in continual   
+358 learning scenarios where the agent never stops learning and keeps accumulating knowledge and skills.   
+359 Future work should also study improved mechanisms for handing over control to pre-trained policies,   
+360 as well as prioritizing the usage of certain behaviors over others when multiple such policies are   
+361 available to the agent. This could overcome one of the current limitations of BT, which assumes that   
+362 flights can be started from any state and still produce meaningful behavior.
+
+References [1] Louis Bagot, Kevin Mets, and Steven Latré. Learning intrinsically motivated options to stimulate policy exploration. In ICML Workshop on LifeLong Learning, 2020. [2] André Barreto, Will Dabney, Rémi Munos, Jonathan J Hunt, Tom Schaul, Hado P van Hasselt, and David Silver. Successor features for transfer in reinforcement learning. In NeurIPS, 2017. [3] Andre Barreto, Diana Borsa, John Quan, Tom Schaul, David Silver, Matteo Hessel, Daniel Mankowitz, Augustin Zidek, and Remi Munos. Transfer in deep reinforcement learning using successor features and generalised policy improvement. In ICML, 2018. [4] André Barreto, Shaobo Hou, Diana Borsa, David Silver, and Doina Precup. Fast reinforcement learning with generalized policy updates. Proceedings of the National Academy of Sciences, 2020. [5] Andrew G Barto and Sridhar Mahadevan. Recent advances in hierarchical reinforcement learning. Discrete event dynamic systems, 2003. [6] Marc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In NeurIPS, 2016. [7] Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 2013. [8] Diana Borsa, André Barreto, John Quan, Daniel Mankowitz, Rémi Munos, Hado van Hasselt, David Silver, and Tom Schaul. Universal successor features approximators. In ICLR, 2019. [9] 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. [10] Yuri Burda, Harri Edwards, Deepak Pathak, Amos Storkey, Trevor Darrell, and Alexei A Efros. Large-scale study of curiosity-driven learning. arXiv preprint arXiv:1808.04355, 2018.   
+8 [11] Yuri Burda, Harrison Edwards, Amos Storkey, and Oleg Klimov. Exploration by random network distillation. arXiv preprint arXiv:1810.12894, 2018.   
+[12] Víctor Campos, Alexander Trott, Caiming Xiong, Richard Socher, Xavier Giro-i Nieto, and Jordi Torres. Explore, discover and learn: Unsupervised discovery of state-covering skills. In ICML, 2020. [13] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In ICML, 2020. [14] Will Dabney, Georg Ostrovski, and André Barreto. Temporally-extended -greedy exploration. In ICLR, 2021. [15] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In NAACL, 2019. [16] 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. In ICML, 2014.   
+[17] Yan Duan, John Schulman, Xi Chen, Peter L Bartlett, Ilya Sutskever, and Pieter Abbeel. RL2: Fast reinforcement learning via slow reinforcement learning. arXiv preprint arXiv:1611.02779, 2016. [18] Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Volodymyr Mnih, Tom Ward, Yotam Doron, Vlad Firoiu, Tim Harley, Iain Dunning, et al. IMPALA: Scalable distributed deep-RL with importance weighted actor-learner architectures. In ICML, 2018.   
+[19] Benjamin Eysenbach, Abhishek Gupta, Julian Ibarz, and Sergey Levine. Diversity is all you need: Learning skills without a reward function. In ICLR, 2019.   
+[20] Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. arXiv preprint arXiv:1703.03400, 2017.   
+[21] Carlos Florensa, Yan Duan, and Pieter Abbeel. Stochastic neural networks for hierarchical reinforcement learning. In ICLR, 2017.   
+[22] Ross Girshick, Jeff Donahue, Trevor Darrell, and Jitendra Malik. Rich feature hierarchies for accurate object detection and semantic segmentation. In CVPR, 2014.   
+[23] Karol Gregor, Danilo Jimenez Rezende, and Daan Wierstra. Variational intrinsic control. arXiv preprint arXiv:1611.07507, 2016.   
+[24] Jean-Bastien Grill, Florian Strub, Florent Altché, Corentin Tallec, Pierre H Richemond, Elena Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv preprint arXiv:2006.07733, 2020.   
+[25] Abhishek Gupta, Benjamin Eysenbach, Chelsea Finn, and Sergey Levine. Unsupervised meta-learning for reinforcement learning. arXiv preprint arXiv:1806.04640, 2018.   
+[26] David Ha and Jürgen Schmidhuber. Recurrent world models facilitate policy evolution. In NeurIPS, 2018.   
+[27] Danijar Hafner, Timothy Lillicrap, Jimmy Ba, and Mohammad Norouzi. Dream to control: Learning behaviors by latent imagination. In ICLR, 2019.   
+[28] Steven Hansen, Will Dabney, Andre Barreto, Tom Van de Wiele, David Warde-Farley, and Volodymyr Mnih. Fast task inference with variational intrinsic successor features. In ICLR, 2020.   
+[29] Elad Hazan, Sham M Kakade, Karan Singh, and Abby Van Soest. Provably efficient maximum entropy exploration. In ICML, 2019.   
+[30] Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. arXiv preprint arXiv:1911.05722, 2019.   
+[31] Olivier J Hénaff, Ali Razavi, Carl Doersch, SM Eslami, and Aaron van den Oord. Data-efficient image recognition with contrastive predictive coding. arXiv preprint arXiv:1905.09272, 2019.   
+[32] Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 1997.   
+[33] Dan Horgan, John Quan, David Budden, Gabriel Barth-Maron, Matteo Hessel, Hado Van Hasselt, and David Silver. Distributed prioritized experience replay. arXiv preprint arXiv:1803.00933, 2018.   
+[34] Allan Jabri, Kyle Hsu, Abhishek Gupta, Ben Eysenbach, Sergey Levine, and Chelsea Finn. Unsupervised curricula for visual meta-reinforcement learning. In Advances in Neural Information Processing Systems, pages 10519–10531, 2019.   
+[35] Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models. arXiv preprint arXiv:2001.08361, 2020.   
+[36] Steven Kapturowski, Georg Ostrovski, John Quan, Remi Munos, and Will Dabney. Recurrent experience replay in distributed reinforcement learning. In ICLR, 2019.   
+[37] Michael Kearns and Satinder Singh. Near-optimal reinforcement learning in polynomial time. Machine learning, 2002.   
+[38] Ilya Kostrikov, Denis Yarats, and Rob Fergus. Image augmentation is all you need: Regularizing deep reinforcement learning from pixels. In ICLR, 2021.   
+[39] Lisa Lee, Benjamin Eysenbach, Emilio Parisotto, Eric Xing, Sergey Levine, and Ruslan Salakhutdinov. Efficient exploration via state marginal matching. arXiv preprint arXiv:1906.05274, 2019.   
+[40] Hao Liu and Pieter Abbeel. Behavior from the void: Unsupervised active pre-training. arXiv preprint arXiv:2103.04551, 2021.   
+[41] Yao Liu and Emma Brunskill. When simple exploration is sample efficient: Identifying sufficient conditions for random exploration to yield pac rl algorithms. arXiv preprint arXiv:1805.09045, 2018.   
+[42] Shakir Mohamed and Danilo Jimenez Rezende. Variational information maximisation for intrinsically motivated reinforcement learning. In NeurIPS, 2015.   
+[43] Mirco Mutti, Lorenzo Pratissoli, and Marcello Restelli. Task-agnostic exploration via policy gradient of a non-parametric state entropy estimate. In AAAI, 2021.   
+[44] Ian Osband, Charles Blundell, Alexander Pritzel, and Benjamin Van Roy. Deep exploration via bootstrapped dqn. arXiv preprint arXiv:1602.04621, 2016.   
+[45] Ian Osband, Benjamin Van Roy, and Zheng Wen. Generalization and exploration via randomized value functions. In ICML, 2016.   
+[46] Deepak Pathak, Pulkit Agrawal, Alexei A Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In ICML, 2017.   
+[47] Adrià Puigdomènech Badia, Bilal Piot, Steven Kapturowski, Pablo Sprechmann, Alex Vitvitskyi, Daniel Guo, and Charles Blundell. Agent57: Outperforming the atari human benchmark. In ICML, 2020.   
+[48] Adrià Puigdomènech Badia, Pablo Sprechmann, Alex Vitvitskyi, Daniel Guo, Bilal Piot, Steven Kapturowski, Olivier Tieleman, Martín Arjovsky, Alexander Pritzel, Andew Bolt, et al. Never give up: Learning directed exploration strategies. In ICLR, 2020.   
+[49] Martin L Puterman. Markov Decision Processes: Discrete Stochastic Dynamic Programming. John Wiley & Sons, Inc., 1994.   
+[50] Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. OpenAI Blog, 2019.   
+[51] Christoph Salge, Cornelius Glackin, and Daniel Polani. Empowerment – an introduction. In Guided Self-Organization: Inception. Springer, 2014.   
+[52] Max Schwarzer, Nitarshan Rajkumar, Michael Noukhovitch, Ankesh Anand, Laurent Charlin, R Devon Hjelm, Philip Bachman, and Aaron Courville. Pretraining reward-free representations for data-efficient reinforcement learning. In Self-Supervision for Reinforcement Learning Workshop - ICLR 2021, 2021. URL https://openreview.net/forum?id $\underset { . } { = }$ o5z9Le5drua.   
+[53] Ramanan Sekar, Oleh Rybkin, Kostas Daniilidis, Pieter Abbeel, Danijar Hafner, and Deepak Pathak. Planning to explore via self-supervised world models. In ICML, 2020.   
+[54] Adam Stooke, Kimin Lee, Pieter Abbeel, and Michael Laskin. Decoupling representation learning from reinforcement learning. arXiv preprint arXiv:2009.08319, 2020.   
+[55] Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.   
+[56] Richard S Sutton, Doina Precup, and Satinder Singh. Between mdps and semi-mdps: A framework for temporal abstraction in reinforcement learning. Artificial intelligence, 1999.   
+[57] Gandhimohan M Viswanathan, V Afanasyev, SV Buldyrev, EJ Murphy, PA Prince, and H Eugene Stanley. Lévy flight search patterns of wandering albatrosses. Nature, 1996.   
+[58] Ziyu Wang, Tom Schaul, Matteo Hessel, Hado Hasselt, Marc Lanctot, and Nando Freitas. Dueling network architectures for deep reinforcement learning. In ICML, 2016.   
+[59] Denis Yarats, Rob Fergus, Alessandro Lazaric, and Lerrel Pinto. Reinforcement learning with prototypical representations. In ICML, 2021.   
+[60] Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? arXiv preprint arXiv:1411.1792, 2014.   
+[61] Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In ECCV, 2014.
+
+# Checklist
+
+The checklist follows the references. Please read the checklist guidelines carefully for information on how to answer these questions. For each question, change the default [TODO] to [Yes] , [No] , or [N/A] . You are strongly encouraged to include a justification to your answer, either by referencing the appropriate section of your paper or providing a brief inline description. For example:
+
+• Did you include the license to the code and datasets? [No] The code and the data are proprietary.
+
+Please do not modify the questions and only use the provided macros for your answers. Note that the Checklist section does not count towards the page limit. In your paper, please delete this instructions block and only keep the Checklist section heading above along with the questions/answers below.
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes]   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [No] We did not include source code because it relies on non-public libraries that are specific to our distributed hardware setting. However, we include all the details needed to replicate our experiments.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] All our experiments were run with three different random seeds. Plots report mean, min and max results. Tables report mean and standard deviation.   
+(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? [N/A]   
+(b) Did you mention the license of the assets? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   
+(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/gG4j9PybfwI/gG4j9PybfwI_content_list.json

@@ -0,0 +1,808 @@
+[
+    {
+        "type": "text",
+        "text": "Beyond Fine-Tuning: Transferring Behavior in Reinforcement Learning ",
+        "text_level": 1,
+        "bbox": [
+            194,
+            122,
+            803,
+            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 Designing agents that acquire knowledge autonomously and use it to solve new   \n2 tasks efficiently is an important challenge in reinforcement learning. Knowledge   \n3 acquired during an unsupervised pre-training phase is often transferred by fine  \n4 tuning neural network weights once rewards are exposed, as is common practice   \n5 in supervised domains. Given the nature of the reinforcement learning problem,   \n6 we argue that standard fine-tuning strategies alone are not enough for efficient   \n7 transfer in challenging domains. We introduce Behavior Transfer (BT), a technique   \n8 that leverages pre-trained policies for exploration and that is complementary to   \n9 transferring neural network weights. Our experiments show that, when combined   \n10 with large-scale pre-training in the absence of rewards, existing intrinsic motivation   \n11 objectives can lead to the emergence of complex behaviors. These pre-trained   \n12 policies can then be leveraged by BT to discover better solutions than without   \n13 pre-training, and combining BT with standard fine-tuning strategies results in   \n14 additional benefits. The largest gains are generally observed in domains requiring   \n15 structured exploration, including settings where the behavior of the pre-trained   \n16 policies is misaligned with the downstream task. ",
+        "bbox": [
+            148,
+            349,
+            766,
+            570
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "17 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            598,
+            310,
+            616
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "18 Transfer in deep learning is often performed through parameter initialization followed by fine-tuning,   \n19 a technique that allows to leverage the power of deep networks in domains where labelled data   \n20 is scarce [60, 16, 61, 22, 15]. This builds on the intuition that the pre-trained model will map   \n21 inputs to a feature space where the downstream task is easy to perform. When combined with   \n22 methods that can leverage massive amounts of unlabelled data for pre-training, this transfer strategy   \n23 has led to unprecedented results in domains like computer vision [31, 30] and natural language   \n24 processing [15, 50]. The success of these approaches has led to an ever-growing interest in developing   \n25 techniques for pre-training large scale models on unlabelled data [9, 13, 24].   \n26 In the reinforcement learning (RL) context, unsupervised methods that learn in the absence of reward   \n27 have also garnered much research attention [23, 21, 46, 19, 29]. The benefits of unsupervised pre  \n28 training are typically evaluated by their ability to enable efficient transfer to previously unseen reward   \n29 functions [28]. In spite of their different approaches to unsupervised RL, most of the top-performing   \n30 methods in this setting transfer knowledge through neural network weights. Such approaches deal   \n31 with the data inefficiency associated to training neural networks with gradient descent, similarly to   \n32 what is done in supervised learning, e.g. by pre-training encoders that extract representations from   \n33 observations [59]. However, RL introduces a challenge that is not present in supervised learning: the   \n34 agent is responsible for collecting the right data to learn from. This introduces a second source of   \n35 inefficiency from which transfer approaches can also suffer if they rely on unstructured exploration   \n36 strategies after pre-training, as these can lead to exponentially larger data requirements in complex   \n37 downstream environments [45, 44]. To address this problem, one could consider fine-tuning policies   \n38 that produce meaningful behavior [43, 52], but this approach quickly disregards the pre-trained   \n39 behavior when learning in the downstream task due to catastrophic forgetting.   \n40 In this work, we explicitly separate the transfer of behaviour and weights. We propose to make   \n41 use of the pre-trained behaviour itself (i.e., the pre-trained policy mapping from observations to   \n42 actions) in contrast to pre-trained neural network weights for further fine-tuning. While pre-trained   \n43 behavior has been used before for exploitation [5, 56, 2, 3], our approach employs pre-trained policies   \n44 to aid with exploration as well to collect experience that can be leveraged via off-policy learning.   \n45 This strategy accelerates learning, as the agent is exposed to potentially useful experience earlier in   \n46 training, without compromising the quality of the discovered solution when the pre-trained behavior   \n47 is not aligned with the downstream task. We expose the pre-trained behaviour to the downstream   \n48 agent in two ways: firstly, as an extra exploratory strategy that, when randomly activated, persists for   \n49 a number of steps, and secondly as an additional pseudo-action for the learned value function where   \n50 the agent may elect to defer action selection to the pre-trained policy instead of choosing itself. We   \n51 call this approach Behavior Transfer (BT).   \n52 Defining unsupervised RL objectives remains an open problem, and solutions are generally influenced   \n53 by how the acquired knowledge will be used for solving downstream tasks. Instead of proposing yet   \n54 another objective for unsupervised pre-training, we turn to existing techniques for training policies in   \n55 the absence of reward and make our choice based on two general requirements. First, the objective   \n56 should scale gracefully with increased compute and data. This has been key for the success of   \n57 self-supervised approaches in other domains [9, 35], and we argue that it is an important property for   \n58 unsupervised RL as well. Second, the pre-training stage should return a policy that produces complex   \n59 behavior that may be leveraged in a subsequent transfer stage. The Never Give Up (NGU) [48]   \n60 intrinsic reward meets both requirements, and our experiments show that large-scale pre-training with   \n61 this objective leads to state of the art scores in the reward-free Atari benchmark.   \n62 Figure 1 exemplifies our main findings. We pre-train behaviour using the intrinsic NGU reward during   \n63 a long unsupervised phase without rewards. This gives rise to exploratory behaviors that seek to visit   \n64 many different states throughout an episode, and we then compare different strategies for leveraging   \n65 the acquired knowledge once rewards are reinstated. While fine-tuning the pre-trained weights   \n66 enables faster learning, the exploratory behavior of the pre-trained policy is quickly disregarded as it   \n67 is exposed to rewards. On the other hand, Behavior Transfer (BT) does not modify the pre-trained   \n68 policy while learning in the new task and is able to achieve higher end scores thanks to better   \n69 exploration. These two strategies are not mutually exclusive, and BT also benefits from the faster   \n70 convergence provided by initializing neural networks with pre-trained weights when these encode   \n71 useful information for solving the downstream task.   \n72 Our contributions can be summarized as follows. (1) We propose Behavior Transfer (BT), a technique   \n73 that leverages pre-trained policies for exploration by treating them as black boxes that are not modified   \n74 during learning on the downstream task. BT uses the pre-trained policy to collect experience in   \n75 two ways, namely randomly-triggered temporally-extended exploration and one-step calls based on   \n76 value estimates. (2) Our experiments show that large-scale unsupervised pre-training with existing   \n77 intrinsic rewards can produce meaningful behavior, achieving state of the art results in the reward-free   \n78 Atari benchmark. These results suggest that scale is key for unsupervised RL, akin to what has been   \n79 observed in supervised settings. (3) We provide extensive empirical evidence demonstrating the   \n80 benefits of leveraging pre-trained behavior via BT. Our approach obtains the largest gains in hard   \n81 exploration games, where it almost doubles the median human normalized score achieved by our   \n82 strongest baseline. Furthermore, we show that BT is able to leverage a single task-agnostic policy   \n83 to solve multiple tasks in the same environment and to achieve high performance even when the   \n84 pre-trained policies are misaligned with the task being solved. (4) BT brings benefits to the table   \n85 that are complementary to those provided by reusing pre-trained neural network weights, and we   \n86 empirically show that combining these two strategies can result in larger gains. ",
+        "bbox": [
+            147,
+            631,
+            825,
+            741
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            747,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/696568b2c84f51d1ef7c367946f1a4c3d2eebbbcb736aedca9ae66aae814bfa2.jpg",
+        "image_caption": [
+            "Figure 1: Comparison of transfer strategies on Montezuma’s Revenge and Defender after pre-training a policy with NGU [48] in the absence of reward. The benefits of our proposed approach to leverage pre-trained behavior for exploration, Behavior Transfer (BT), are complementary to the gains provided by pre-trained weight initialization followed by fine-tuning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            90,
+            818,
+            195
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            290,
+            825,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            339,
+            825,
+            505
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            511,
+            825,
+            648
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            656,
+            825,
+            794
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            92,
+            825,
+            189
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "87 2 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            207,
+            318,
+            224
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "88 The interaction between the agent and the environment is modelled as a Markov Decission Pro  \n89 cess (MDP) [49]. An MDP is defined by the tuple $( S , A , P , d _ { 0 } , R , \\gamma )$ where $s$ and $\\mathcal { A }$ are the state   \n90 and action spaces, $P ( s ^ { \\prime } | s , a )$ is the probability of transitioning from state $s$ to $s ^ { \\prime }$ after taking action $a$   \n91 $d _ { 0 } ( s )$ is the probability distribution over initial states, $R : S \\times \\mathcal { A } \\times \\mathcal { S }  \\mathbb { R }$ is the reward function,   \n92 and retu $\\gamma \\in [ 0 , 1 )$ $\\begin{array} { r } { \\dot { G } _ { t } = \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } R _ { t } } \\end{array}$ unt fact, where $R _ { t } = r \\hat { ( } S _ { t } , A _ { t } , S _ { t + 1 } )$ a policy . A prin $\\pi ( a | s )$ that maximizes the expected way to address this problem   \n94 is to use methods that compute action-value functions, $Q ^ { \\pi } ( \\bar { s } , a ) \\overset { - } { = } \\mathbb { E } _ { \\pi } \\left[ G _ { t } \\vert S _ { t } = s , A _ { t } = a \\right]$ , where   \n95 $\\mathbb { E } _ { \\pi } [ \\cdot ]$ denotes expectation over transitions induced by $\\pi$ [49].   \n96 We consider a setting where the agent is allowed to first learn within an MDP without rewards,   \n97 $\\boldsymbol { \\mathcal { M } } ^ { R } = ( \\boldsymbol { \\mathcal { S } } , \\boldsymbol { \\mathcal { A } } , P , d _ { 0 } )$ , for a long period of time. The knowledge acquired during the reward-free   \n98 stage is later leveraged when maximizing reward in new MDPs that share the same underlying   \n99 dynamics but have different reward functions, $\\mathcal { M } _ { i } = ( S , A , P , d _ { 0 } , R _ { i } , \\gamma _ { i } )$ . Interactions between the   \n100 agent and the environment are often assumed to incur a cost, but we will consider this cost to be   \n101 relevant only for transitions with reward [28]. Even if the cost of unsupervised pre-training becomes   \n102 non-negligible, it can be amortized when the acquired task-agnostic knowledge is leveraged to solve   \n103 multiple tasks efficiently [15, 9]. Indeed, we would expect this transfer setting to become more   \n104 relevant as the community moves towards more complex environments, where one may want to   \n105 train agents to maximize multiple reward functions under constant dynamics. In the limit, one could   \n106 consider the real world: it has constant or slowly changing dynamics, and humans are able to leverage   \n107 previously acquired skills to quickly master new tasks. ",
+        "bbox": [
+            147,
+            237,
+            825,
+            349
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            354,
+            825,
+            523
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "108 3 Behavior Transfer ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            542,
+            357,
+            559
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "109 Transfer in supervised domains often exploits the fact that related tasks might be solved using similar   \n110 representations. This practice deals with the data inefficiency of training large neural networks   \n111 with stochastic gradient descent. However, there is an additional source of data inefficiency when   \n112 training RL agents: unstructured exploration. Fine-tuning a pre-trained exploratory policy arises as   \n113 a potential strategy for overcoming this problem, as the agent will observe rich experience much   \n114 earlier in training than when initializing the policy randomly, but this approach suffers from important   \n115 limitations. Learning in the downstream task can lead to catastrophically forgetting the pre-trained   \n116 policy, thus prematurely disregarding its exploratory behavior. Moreover, the same neural network   \n117 architecture needs to be used for both the pre-trained and the downstream policies, which in practice   \n118 also imposes a limitation on the type of RL methods that can be employed in the adaptation stage (for   \n119 instance, if the pre-trained policy was trained using a policy-based method, it might not be possible   \n120 to fine-tune it using a value-based approach).   \n121 Let us assume that we have access to a pre-trained policy that exhibits exploratory behavior, and   \n122 defer the discussion on how to train this policy to Section 4. Following such a policy might bring   \n123 the agent to states that are unlikely to be visited with unstructured exploration techniques such as   \n124 $\\epsilon$ -greedy [55]. This property has the potential of accelerating learning even when the behavior of   \n125 the pre-trained policy is not aligned with the downstream task, as it will effectively shorten the   \n126 path between otherwise distant states [41]. Leveraging pre-trained policies for exploration differs   \n127 from other approaches in the literature that use such policies directly for exploitation, e.g. via   \n128 zero-shot transfer [19], methods that define a higher-level policy that alternates between the given   \n129 policies [5, 56], or within the framework of generalized policy updates [4]. Exploring with pre-trained   \n130 policies can accelerate convergence by providing useful experience to the agent, which is possible   \n131 even when the pre-training and downstream tasks are misaligned. However, strategies that directly   \n132 use the pre-trained policies for exploitation may result in sub-optimal solutions in such scenario [2].   \n133 We propose to leverage the behavior of pre-trained policies during transfer to aid with exploration. An   \n134 explicit distinction between behavior and representation is made by considering pre-trained policies as   \n135 black boxes that take observations and return actions. This strategy is agnostic to how the pre-trained   \n136 behavior is encoded and is not restricted to learned policies. We rely on off-policy learning methods   \n137 during transfer to leverage the behavior of a pre-trained policy $\\bar { \\pi _ { p } ( a | s ) }$ . We keep $\\pi _ { p }$ fixed during   \n138 transfer, which prevents catastrophic forgetting of the original behavior when it is parameterized by a   \n139 neural network (i.e., we instantiate and train a new policy with its own set of parameters). We propose   \n140 Behavior Transfer (BT), which leverages two complementary strategies to achieve this. Since BT   \n141 is agnostic to the method used to pre-train policies, $B T ( \\pi _ { p } )$ refers to behavior being transferred   \n142 from policy $\\pi _ { p }$ . We formalize BT in the context of value-based Q-learning agents, although similar   \n143 derivations are in principle possible for alternative off-policy learning methods. Pseudo-code for BT   \n144 is provided in Algorithm 1.   \n145 Temporally-extended exploration. We draw inspiration from Lévy flights [57], a class of ecological   \n146 models for animal foraging, where a fixed direction is followed for a duration sampled from a   \n147 heavy-tailed distribution. This principle was implemented in the context of exploration in RL by   \n148 $\\epsilon z$ -greedy [14], which encodes the notion of direction in the environment via exploration options that   \n149 repeat the same action throughout the entire flight. Since $\\pi _ { p }$ is more likely to encode a meaningful   \n150 notion of direction in complex environments than action repeats, we propose a variant of $\\epsilon z$ -greedy   \n151 where $\\pi _ { p }$ is used as the exploration option. An exploratory flight might be started at any step with   \n152 some probability. The duration for the flight is sampled from a heavy-tailed distribution (Zeta with   \n153 $\\mu = 2$ in all our experiments), and control is handed over to $\\pi _ { p }$ during the complete flight. When not   \n154 in a flight, actions are sampled from the behavior policy obtained while maximizing the task reward   \n155 (e.g. an $\\epsilon$ -greedy derived from the estimated Q values).   \n156 Extra action. The previous approach switches to $\\pi _ { p }$ during experience collection blindly, and we   \n157 now consider an alternative strategy for triggering these switches based on value. This can be easily   \n158 implemented through an extra action which samples an action from $\\pi _ { p }$ , which also allows the agent to   \n159 use the pre-trained policy at test time if deemed beneficial. More formally, this amounts to training a   \n160 policy over an expanded action set $\\mathcal { A } ^ { + } = \\mathcal { A } \\cup \\{ a _ { + } \\}$ , where $a _ { + }$ is resolved by sampling an action from   \n161 $\\pi _ { p }$ , $a ^ { \\prime } \\sim \\pi _ { p } ( s )$ (with $a ^ { \\prime } \\in { \\mathcal { A } }$ ). The additional action can be seen as an option that can be initiated   \n162 from any state and always terminates after a single step. Note that selecting the option will lead to   \n163 the same outcome as if the agent had selected $a ^ { \\prime }$ as a primitive action, and we take advantage of this   \n164 observation by using the return of following the option as target to fit both $Q ( s , \\pi _ { p } ( s ) )$ and $Q ( s , a ^ { \\prime } )$ .   \n165 Intuitively, this approach induces a bias that favours actions selected by $\\pi _ { p }$ , accelerating the collection   \n166 of rewarding transitions when the pre-trained policy is somewhat aligned with the downstream task.   \n167 Otherwise, the agent can learn to ignore $\\pi _ { p }$ as training progresses by selecting other actions. ",
+        "bbox": [
+            140,
+            573,
+            825,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            746,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            92,
+            825,
+            257
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            263,
+            825,
+            416
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            421,
+            825,
+            588
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Experience collection pseudo-code for BT ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            608,
+            545,
+            623
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Input: Action set, $\\mathcal { A }$ ; additional action, $a _ { + }$ ; extended action set, $\\mathcal { A } ^ { + } = \\mathcal { A } \\cup \\{ a _ { + } \\}$ ; pre-trained policy, $\\pi _ { p }$ ; Q-value estimate for the current policy, $Q ^ { \\pi } ( s , a ) \\forall a \\in A ^ { + }$ ; probability of taking an exploratory action, $\\epsilon$ ; probability of starting a flight, $\\epsilon _ { \\mathrm { l e v y } }$ ; flight length distribution, $\\mathcal { D } ( \\mathbb { N } )$   \nwhile True do $n \\gets 0$ // flight length while episode not ended do Observe state $s$ if $n = = 0$ and random $) \\le \\epsilon _ { l e v y }$ then $n \\sim \\mathcal { D } ( \\mathbb { N } )$ // sample flight length if $n > 0$ then $\\begin{array} { l } { n  n - 1 } \\\\ { a \\sim \\pi _ { p } ( s ) } \\end{array}$ else if random $) \\leq \\epsilon$ then $a \\sim \\operatorname { U n i f o r m } ( \\mathcal { A } ^ { + } )$ else $a \\gets \\arg \\operatorname* { m a x } _ { a ^ { \\prime } \\in \\mathcal { A } ^ { + } } [ Q ^ { \\pi } ( s , a ^ { \\prime } ) ]$ if $a = = a _ { + }$ then $a \\sim \\pi _ { p } ( s )$ end Take action $a$ end   \nend ",
+        "bbox": [
+            171,
+            627,
+            812,
+            895
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "169 It is a common practice to derive objectives for proxy tasks in order to drive learning in the absence   \n170 of reward functions, and there exists a plethora of different approaches in the literature. Model-based   \n171 approaches can learn world models from unsupervised interaction [26]. However, the diversity of   \n172 the training data will impact the accuracy of the model [53] and deploying this type of approach   \n173 in visually complex domains like Atari remains an open problem [27]. Unsupervised RL has also   \n174 been explored through the lens of empowerment [51, 42], which studies agents that aim to discover   \n175 intrinsic options [23, 19]. While these options can be leveraged by hierarchical agents [21] or   \n176 integrated within the universal successor features framework [2, 3, 8, 28], their potential lack of   \n177 coverage generally limits their applicability to complex downstream tasks [12]. An alternative   \n178 objective is that of exploring the environment by finding policies that induce maximally entropic state   \n179 distributions [29, 39], although this might become extremely inefficient in high-dimensional state   \n180 spaces without proper priors [40, 59].   \n181 Recall that our goal is to devise a pre-training objective that can help reduce the amount of interaction   \n182 needed by the agent to collect relevant experience when learning in a downstream task. We argue that   \n183 such objective needs to meet two requirements. First, as suggested by results in other domains [9, 35],   \n184 it should scale gracefully as the amount of compute and experience used for pre-training are increased.   \n185 This contrasts with the training regimes used in most unsupervised RL approaches, which use a   \n186 relatively small amount of experience [28, 40, 59] when compared to distributed agents that do make   \n187 use of rewards [33, 18, 36]. Second, it must encourage the emergence of complex behaviors such as   \n188 navigation or manipulation skills. It has been argued that exploring the environment efficiently will   \n189 serve as a proxy for developing such behaviors [37], and exploration bonuses have been shown to   \n190 produce meaningful behavior in the absence of reward [46, 10]. However, many exploration bonuses   \n191 vanish over the course of training and thus may not be well-suited for a long unsupervised pre-training   \n192 phase. It can be shown that many intrinsic rewards aim at maximizing the entropy of all states visited   \n193 during training, and so the final policy does not necessarily exhibit exploratory behavior [39].   \n194 We propose to use Never Give Up (NGU) [48] as a means for training exploratory policies in an   \n195 unsupervised setting. The NGU intrinsic reward proposes a curiosity-driven approach for training   \n196 persistent exploratory policies which combines per-episode and life-long novelty. The per-episode   \n197 novelty, $r _ { t } ^ { \\mathrm { e p i s o d i c } }$ , rapidly vanishes over the course of an episode, and it is designed to encourage self  \n198 avoiding trajectories. It is computed by comparing a representation of the current observation, $f ( s _ { t } )$ ,   \n199 to those of all the observations visited in the current episode, $M = \\{ f ( s _ { 0 } ) , f ( s _ { 1 } ) , \\dotsc , f ( s _ { t - 1 } ) \\}$ ,   \n200 where $f : \\mathcal { S }  \\mathbb { R } ^ { p }$ is an embedding function trained using a self-supervised inverse dynamics   \n201 model [46]. Such a mapping concentrates on the controllable aspects of the environment, ignoring   \n202 all the variability present in the observation that is not affected by the action taken by the agent.   \n203 The life-long novelty, $\\alpha _ { t }$ , slowly vanishes throughout training, and it is computed by using Random   \n204 Network Distillation (RND) [11]. With this, the intrinsic reward $r _ { t } ^ { \\mathrm { { N G U } } }$ is defined as follows: ",
+        "bbox": [
+            140,
+            119,
+            825,
+            286
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            291,
+            825,
+            472
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            478,
+            826,
+            632
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2cf425b1a7b90f7cacb526d3f495baaf4b7fa24891c413c5e56b02f32bc19b61.jpg",
+        "text": "$$\nr _ { t } ^ { \\mathrm { N G U } } = r _ { t } ^ { \\mathrm { { e p i s o d i c } } } \\cdot \\operatorname* { m i n } \\left\\{ \\operatorname* { m a x } \\left\\{ \\alpha _ { t } , 1 \\right\\} , L \\right\\} , \\mathrm { ~ w i t h } r _ { t } ^ { \\mathrm { e p i s o d i c } } = \\frac { 1 } { \\sqrt { \\sum _ { f ( s _ { t } ) \\in N _ { k } } K ( f ( s _ { t } ) , f ( s _ { i } ) ) + c ^ { 2 } } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            637,
+            799,
+            679
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "205 where $L$ is a fixed maximum reward scaling, $N _ { k }$ is the set containing the $k$ -nearest neighbors of $f ( s _ { t } )$   \n206 in $M$ , $c$ is a constant and $K : \\mathbb { R } ^ { p } \\times \\mathbb { R } ^ { p } \\to \\mathbb { R } ^ { + }$ is a kernel function satisfying $K ( x , { \\bar { x } } ) = 1$ (which   \n207 can be thought of as approximating pseudo-counts [48]). The episodic component of the reward   \n208 in Equation 1 is reset by emptying $M$ with each episode, thus the NGU reward does not vanish   \n209 throughout the training process. This makes it suitable for driving learning in task-agnostic settings.   \n210 Further details on NGU are reported in the supplementary material. ",
+        "bbox": [
+            140,
+            681,
+            825,
+            765
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "211 5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            784,
+            312,
+            800
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "212 Agents are evaluated in the Atari suite [7], a benchmark that presents a variety of challenges and that   \n213 is a common test ground for RL agents with unsupervised pre-training [28, 40, 52]. Experiments are   \n214 run using the distributed R2D2 agent [36] with 256 CPU actors and a single GPU learner. Policies   \n215 use the same Q-Network architecture as Agent57 [47], which is composed by a convolutional torso   \n216 followed by an LSTM [32] and a dueling head [58]. Hyperparameters and a detailed description of   \n217 the full distributed setting are provided in the supplementary material. All reported results are the   \n218 average over three random seeds.   \n219 Reward-free learning. The amount of task reward collected by unsupervised policies is often   \n220 used as a proxy to measure their quality [19]. While the actual utility of these policies will not   \n221 be revealed until they are leveraged for transfer, this proxy lets us evaluate whether the discovered   \n222 behavior changes as longer pre-training budgets are allowed. We compare unsupervised NGU policies   \n223 against VISR [28] and APT [40], which utilize a small amount of supervised interaction to adapt   \n224 the pre-trained policies. We also consider two additional unsupervised baselines: $( i )$ a constant   \n225 positive reward at each timestep that favours long episodes, which correlate with high scores in some   \n226 games [10], and (ii) RND [11], which rewards life-long novelty. Note that the RND reward vanishes,   \n227 but we include it in our analysis because it was previously used by Burda et al. [10] in this setting   \n228 and implementation choices such as reward normalization may prevent it from fading in practice.   \n229 Figure 2 (left) shows how the zero-shot transfer performance of unsupervised policies evolves during   \n230 a long pre-training phase. NGU reaches the highest scores, but both NGU and RND eventually   \n231 outperform VISR and APT even though these used supervised interaction. In Table 2 of Appendix   \n232 C we show that unsupervised NGU policies largely outperform several other baselines using the   \n233 standard pre-training and adaptation setting. These results highlight the importance of large-scale   \n234 unsupervised pre-training in RL, similarly to the trend observed in supervised domains [9]. ",
+        "bbox": [
+            140,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            92,
+            825,
+            313
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/693f32859ff6d9b0ac39d33ab71c1a54485c1fe8c8c24525070d8a48b2d7618d.jpg",
+        "image_caption": [
+            "Figure 2: Performance as a function of the pre-training budget. $@ N$ represents the number of frames with reward utilized for transfer. (Left) Median human normalized score across the 57 games in the Atari suite. We observe the emergence of useful behavior when optimizing an intrinsic reward during a long unsupervised pre-training of 16B frames, which contrasts with the shorter pre-training of 1B frames in previous works [28, 40]. (Right) Scores in the games of Montezuma’s Revenge (sparse rewards) and Pong (dense reward), before and after transfer, as a function of the pre-training budget. A longer pre-training benefits transfer in hard exploration games even if the zero-shot transfer score of the unsupervised policies does not increase. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            316,
+            818,
+            422
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Transfer setting. Transfer approaches are typically evaluated in the Atari benchmark with a budget of 100k RL interactions with reward (400k frames), but we propose to allow a longer adaptation phase. Randomly initialized networks tend to overfit in these very low data regimes without strong regularization [38], and we are interested in studying the impact of leveraging behavior both in isolation and combined with transfer via pre-trained weights. Moreover, since the pre-trained policies are already competent in the downstream tasks, $1 0 0 \\mathrm { k }$ interactions are exhausted after few episodes and may be insufficient for improving performance. For these reasons, we provide results with up to 1.25B RL steps of supervised interaction (5B frames). This allows evaluating both convergence speed and asymptotic performance, while still being a relatively small budget for these distributed agents with hundreds of actors [47]. ",
+        "bbox": [
+            169,
+            551,
+            825,
+            689
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Transfer via behavior. We start by studying the impact of leveraging behavior in isolation, i.e. without transferring pre-trained weights, when learning in downstream tasks. We compare BT against two baselines that do not use pre-trained behavior, namely the standard R2D2 agent [36] that uses $\\epsilon$ -greedy policies for exploration [55], as well as a variant of R2D2 with $\\epsilon z$ -greedy exploration [14]. Figure 3 shows that BT is superior to both baselines for any amount of environment interaction with rewards, converging faster early in training and also obtaining higher asymptotic performance. These results also demonstrate the generality of the proposed approach, as it is able to benefit from both RND and NGU policies. Note that BT performs particularly well in the set of six hard exploration games1 defined by Bellemare et al. [6], which is aligned with our intuition that reusing behavior helps overcoming the inefficiency associated to unstructured exploration. Figure 2 (right) confirms that a long pre-training phase is especially important in hard exploration games such as Montezuma’s Revenge, even it they do not translate into higher zero-shot transfer scores, as it produces more exploratory behavior. On the other hand, the performance after transfer is independent of the amount of pre-training in dense reward games like Pong, where unstructured exploration is enough to reach optimal scores. ",
+        "bbox": [
+            173,
+            695,
+            826,
+            890
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/7d402b37236621f24b6311f0a942112738113dc64eef0e4d23aa624852764151.jpg",
+        "image_caption": [
+            "Figure 3: Median human normalized scores for R2D2-based agents trained from scratch. (Left) Full Atari suite. (Right) Subset of hard exploration games. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            90,
+            818,
+            210
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/985bc0ee229912f07e0229f480c5d0bf49fcef58c9fea4c4c5d8bc5084e081c9.jpg",
+        "image_caption": [
+            "Figure 4: Usage of the extra action in $\\mathrm { B T } ( \\pi _ { \\mathrm { N G U } } )$ , computed as the fraction of steps within an episode in which it is selected by the agent. The usage peaks early in training and slowly decreases afterwards as the new policy becomes stronger at the task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            258,
+            820,
+            348
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "259 Ablation studies. In order to gain insight on each of the components in BT, we run experiments   \n260 on a subset of 12 games2 requiring different amounts of exploration and featuring both dense and   \n261 sparse rewards. $\\mathbf { B T } ( \\pi _ { \\mathrm { N G U } } )$ achieves a median score of 368 in this subset, which compares favorably   \n262 to the 196 median score of R2D2 with $\\epsilon$ -greedy exploration. Removing either the extra action or   \n263 the temporally-extended exploration reduces the median score of $\\mathbf { B T } ( \\pi _ { \\mathrm { N G U } } )$ to 224. These results   \n264 suggest that the gains provided by both strategies are complementary, and both are responsible for the   \n265 strong performance of BT. To provide further insight about the benefits of BT, Figure 4 reports the   \n266 fraction of steps per episode in which the extra action is selected by the greedy policy. It hints at the   \n267 emergence of a schedule over the usage of the pre-trained policy, which increases early in training   \n268 and decays afterwards. We hypothesize that this is due to the fact that the unsupervised policies   \n269 obtain large episodic returns, but their behavior is suboptimal when maximizing discounted rewards.   \n270 These policies take many exploratory actions in between rewards, and so the agent eventually figures   \n271 out more efficient strategies for reaching rewarding states by using primitive actions. ",
+        "bbox": [
+            140,
+            428,
+            825,
+            607
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Transfer to multiple tasks. An appealing property of task-agnostic knowledge is that it can be leveraged to solve multiple tasks. In the RL setting, this can be evaluated by leveraging a single task-agnostic policy for solving multiple tasks (i.e. reward functions) in the same environment. We evaluate whether the unsupervised NGU policies can be useful beyond the standard Atari tasks by creating two alternative versions of Ms Pacman and Hero with different levels of difficulty. The goal in the modified version of Ms Pacman is to eat vulnerable ghosts, with pac-dots giving 0 (easy version) or $- 1 0$ (hard version) points. In the modified version of Hero, saving miners gives a fixed return of 1000 points and dynamiting walls gives either 0 (easy version) or $- 3 0 0$ (hard version) points. The rest of rewards are removed, e.g. eating fruit in Ms Pacman or the bonus for unused power units in Hero. Note that even in the easy version of the games exploration is harder than in their original counterparts, as there are no small rewards guiding the agent towards its goals. Exploration is even more challenging in the hard version of the games, as the intermediate rewards work as a deceptive signal that takes the agent away from its actual goal. In this case, finding rewarding behaviors requires a stronger commitment to an exploration strategy. Unsupervised NGU policies often achieve very low or even negative rewards in this setting, which contrasts with the strong performance they showed when evaluated under the standard game reward. Figure 5 shows that leveraging the behavior of pre-trained exploration policies provides important gains even in this adversarial scenario. These results suggest that the strong performance observed under the standard game rewards is not due to an ",
+        "bbox": [
+            158,
+            613,
+            825,
+            862
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b2e9bc9d03e347e12efc286b6a57b2532360ce7edf0ad56c7d736b2ec11175b8.jpg",
+        "image_caption": [
+            "Figure 5: Scores in Atari games with modified reward functions. We train a single task-agnostic policy per environment, and leverage it to solve three different tasks: the standard game reward, a task with sparse rewards (easy), and a variant of the same task with deceptive rewards (hard). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            90,
+            821,
+            212
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "90 alignment between the NGU reward and the game goals, but due to an efficient usage of pre-trained   \n1 exploration policies.   \n292 Combining pre-trained behavior and weights. Our last batch of experiments focuses on studying   \n293 transfer via pre-trained weights and its compatibility with BT. Policies are composed of a convo  \n294 lutional torso, an LSTM, and a dueling head. We consider two initialization strategies: a partial   \n295 initialization approach that loads the torso and the LSTM, but initializes the head randomly; and a   \n296 full initialization scheme where all weights are loaded. The former can be understood as transferring   \n297 learned representations [59], but deferring exploration to a random policy. On the other hand, the   \n298 full initialization approach can be seen as directly transferring the policy and is usually referred to as   \n299 fine-tuning the pre-trained policy [43, 40, 52]. Note that these approaches only change how weights   \n300 are initialized before training. As in previous experiments, all parameters in the new policy are trained   \n301 and $\\pi _ { p }$ is kept fixed when using BT. Figure 6 (top) compares agents with and without BT for different   \n302 amounts of transfer via weights on the Atari benchmark. Loading pre-trained weights results in faster   \n303 learning early in training, both with and without BT. The largest gains are observed in dense reward   \n304 games, which translates into higher median scores across the full suite because most games belong   \n305 to this category. Weights alone are not enough in hard exploration games, where leveraging the   \n306 pre-trained policy via BT provides clear benefits. Perhaps surprisingly, we observe that transferring   \n307 representations outperforms fine-tuning the pre-trained policy, and we hypothesize that the former   \n308 is more robust to misalignments between the pre-trained policy and the downstream task. This   \n309 intuition is further supported by the experiments on games with modified reward functions reported   \n310 in Figure 6 (middle & bottom), where the faster learning provided by pre-trained weights often comes   \n311 at the cost of lower end scores. On the other hand, BT is crucial in tasks with sparse and deceptive   \n12 rewards and also benefits from pre-trained weights in tasks where positive transfer is observed. ",
+        "bbox": [
+            155,
+            291,
+            825,
+            319
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            325,
+            825,
+            616
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 Related work ",
+        "text_level": 1,
+        "bbox": [
+            158,
+            637,
+            316,
+            654
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "314 Our work uses the experimental methodology presented by Hansen et al. [28]. Whereas that work only   \n315 considered a fast, simplified adaptation process that limited the final performance on the downstream   \n316 task, we focus on the more general case of using a previously trained policy to aid in solving the   \n317 full RL problem. Hansen et al. [28] use successor features to identify which of the pre-trained tasks   \n318 best matches the true reward structure, which has previously been shown to work well for multi-task   \n319 transfer [3]. Bagot et al. [1] augments an agent with the ability to utilize another policy, which is   \n320 learned in tandem based on an intrinsic reward function. This promising direction is complementary   \n321 to our work, as it handles the case wherein there is no unsupervised pre-training phase.   \n322 Gupta et al. [25] provides an alternative method to meta-learn a solver for reinforcement learning prob  \n323 lems from unsupervised reward functions. This method utilizes gradient-based meta-learning [20],   \n324 which makes the adaptation process standard reinforcement learning updates. This means that even if   \n325 the downstream reward is far outside of the training distribution, final performance would not neces  \n326 sarily be affected. However, these methods are hard to scale to the larger networks considered here,   \n327 and followup work [34] changed to memory-based meta-learning [17] which relies on information   \n328 about rewards staying in the recurrent state. This makes it unsuitable to the sort of hard exploration   \n329 problem our method excels at. Recent work has shown success in transferring representations learned   \n330 in an unsupervised setting to reinforcement learning tasks [54]. Our representation transfer experi  \n331 ments suggest that this might handicap final performance, but the possibility also exists that different   \n332 unsupervised objectives should be used for representation transfer and policy transfer. ",
+        "bbox": [
+            148,
+            670,
+            825,
+            780
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/789522c1b91b64812aefceb54c6d2e5dabd3c5fb5585eb5b04e66c0ba732af86.jpg",
+        "image_caption": [
+            "Figure 6: Performance of R2D2-based agents with different amounts of transfer via weights. Policies are composed of a CNN encoder followed by an LSTM and a dueling head. We compare training from scratch, loading all weights (Full $\\pi _ { \\mathrm { N G U } }$ init) or all weights except those in the dueling head (Partial $\\pi _ { \\mathrm { { N G U } } }$ init). (Top) Median human normalized scores (HNS) in the full Atari suite (left) and the subset of hard exploration games (right). (Middle & Bottom) Games with modified reward functions as in Figure 5. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            92,
+            821,
+            304
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            420,
+            825,
+            449
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            158,
+            470,
+            292,
+            488
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We studied the problem of transferring pre-trained behavior for exploration in reinforcement learning, an approach that is complementary to the common practice of transferring neural network weights. Our proposed approach, Behavior Transfer (BT), relies on the pre-trained policy for collecting experience in two different ways: (i) through temporally-extended exploration, which can be triggered with some probability at any step, and $( i i )$ via one-step calls to the pre-trained policy based on value estimates. BT results in strong transfer performance when combined with exploratory policies pretrained in the absence of reward, with the most important gains being observed in hard exploration tasks. These benefits are not due to an alignment between our pre-training and downstream tasks, as we also observed positive transfer in games where the pre-trained policy obtained low scores. In order to provide further evidence for this claim, we designed alternative tasks for Atari games involving hard exploration and deceptive rewards. Our transfer strategy outperformed all considered baselines in these settings, even when the pre-trained policy obtained very low or even negative scores, demonstrating the generality of the method. Besides disambiguating the role of the alignment between pre-training and downstream tasks, these experiments demonstrate the utility of a single task-agnostic policy for solving multiple tasks in the same environment. Finally, we also demonstrated that BT can be combined with transfer via neural network weights to provide further gains. ",
+        "bbox": [
+            169,
+            505,
+            825,
+            724
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "350 Our experimental results highlight the importance of scale when training RL agents in reward-free   \n351 settings, which is one of the key factors behind the recent success of unsupervised approaches in other   \n352 domains. This contrasts with the small budgets considered for reward-free RL in previous works and   \n353 motivates further research in unsupervised RL approaches that scale with increased data and compute.   \n354 We argue that scale is one of the missing components in reward-free RL, and it will be a necessary   \n355 condition to unfold its full potential. Beyond improving the unsupervised learning phase, we are also   \n356 excited about the possibilities unlocked by BT and that are not possible when transferring knowledge   \n357 through weights, such as leveraging multiple pre-trained policies and deploying BT in continual   \n358 learning scenarios where the agent never stops learning and keeps accumulating knowledge and skills.   \n359 Future work should also study improved mechanisms for handing over control to pre-trained policies,   \n360 as well as prioritizing the usage of certain behaviors over others when multiple such policies are   \n361 available to the agent. This could overcome one of the current limitations of BT, which assumes that   \n362 flights can be started from any state and still produce meaningful behavior. ",
+        "bbox": [
+            140,
+            731,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References [1] Louis Bagot, Kevin Mets, and Steven Latré. Learning intrinsically motivated options to stimulate policy exploration. In ICML Workshop on LifeLong Learning, 2020. [2] André Barreto, Will Dabney, Rémi Munos, Jonathan J Hunt, Tom Schaul, Hado P van Hasselt, and David Silver. Successor features for transfer in reinforcement learning. In NeurIPS, 2017. [3] Andre Barreto, Diana Borsa, John Quan, Tom Schaul, David Silver, Matteo Hessel, Daniel Mankowitz, Augustin Zidek, and Remi Munos. Transfer in deep reinforcement learning using successor features and generalised policy improvement. In ICML, 2018. [4] André Barreto, Shaobo Hou, Diana Borsa, David Silver, and Doina Precup. Fast reinforcement learning with generalized policy updates. Proceedings of the National Academy of Sciences, 2020. [5] Andrew G Barto and Sridhar Mahadevan. Recent advances in hierarchical reinforcement learning. Discrete event dynamic systems, 2003. [6] Marc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In NeurIPS, 2016. [7] Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 2013. [8] Diana Borsa, André Barreto, John Quan, Daniel Mankowitz, Rémi Munos, Hado van Hasselt, David Silver, and Tom Schaul. Universal successor features approximators. In ICLR, 2019. [9] 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. [10] Yuri Burda, Harri Edwards, Deepak Pathak, Amos Storkey, Trevor Darrell, and Alexei A Efros. Large-scale study of curiosity-driven learning. arXiv preprint arXiv:1808.04355, 2018.   \n8 [11] Yuri Burda, Harrison Edwards, Amos Storkey, and Oleg Klimov. Exploration by random network distillation. arXiv preprint arXiv:1810.12894, 2018.   \n[12] Víctor Campos, Alexander Trott, Caiming Xiong, Richard Socher, Xavier Giro-i Nieto, and Jordi Torres. Explore, discover and learn: Unsupervised discovery of state-covering skills. In ICML, 2020. [13] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In ICML, 2020. [14] Will Dabney, Georg Ostrovski, and André Barreto. Temporally-extended \u000f-greedy exploration. In ICLR, 2021. [15] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In NAACL, 2019. [16] 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. In ICML, 2014.   \n[17] Yan Duan, John Schulman, Xi Chen, Peter L Bartlett, Ilya Sutskever, and Pieter Abbeel. RL2: Fast reinforcement learning via slow reinforcement learning. arXiv preprint arXiv:1611.02779, 2016. [18] Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Volodymyr Mnih, Tom Ward, Yotam Doron, Vlad Firoiu, Tim Harley, Iain Dunning, et al. IMPALA: Scalable distributed deep-RL with importance weighted actor-learner architectures. In ICML, 2018.   \n[19] Benjamin Eysenbach, Abhishek Gupta, Julian Ibarz, and Sergey Levine. Diversity is all you need: Learning skills without a reward function. In ICLR, 2019.   \n[20] Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. arXiv preprint arXiv:1703.03400, 2017.   \n[21] Carlos Florensa, Yan Duan, and Pieter Abbeel. Stochastic neural networks for hierarchical reinforcement learning. In ICLR, 2017.   \n[22] Ross Girshick, Jeff Donahue, Trevor Darrell, and Jitendra Malik. Rich feature hierarchies for accurate object detection and semantic segmentation. In CVPR, 2014.   \n[23] Karol Gregor, Danilo Jimenez Rezende, and Daan Wierstra. Variational intrinsic control. arXiv preprint arXiv:1611.07507, 2016.   \n[24] Jean-Bastien Grill, Florian Strub, Florent Altché, Corentin Tallec, Pierre H Richemond, Elena Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv preprint arXiv:2006.07733, 2020.   \n[25] Abhishek Gupta, Benjamin Eysenbach, Chelsea Finn, and Sergey Levine. Unsupervised meta-learning for reinforcement learning. arXiv preprint arXiv:1806.04640, 2018.   \n[26] David Ha and Jürgen Schmidhuber. Recurrent world models facilitate policy evolution. In NeurIPS, 2018.   \n[27] Danijar Hafner, Timothy Lillicrap, Jimmy Ba, and Mohammad Norouzi. Dream to control: Learning behaviors by latent imagination. In ICLR, 2019.   \n[28] Steven Hansen, Will Dabney, Andre Barreto, Tom Van de Wiele, David Warde-Farley, and Volodymyr Mnih. Fast task inference with variational intrinsic successor features. In ICLR, 2020.   \n[29] Elad Hazan, Sham M Kakade, Karan Singh, and Abby Van Soest. Provably efficient maximum entropy exploration. In ICML, 2019.   \n[30] Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. arXiv preprint arXiv:1911.05722, 2019.   \n[31] Olivier J Hénaff, Ali Razavi, Carl Doersch, SM Eslami, and Aaron van den Oord. Data-efficient image recognition with contrastive predictive coding. arXiv preprint arXiv:1905.09272, 2019.   \n[32] Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 1997.   \n[33] Dan Horgan, John Quan, David Budden, Gabriel Barth-Maron, Matteo Hessel, Hado Van Hasselt, and David Silver. Distributed prioritized experience replay. arXiv preprint arXiv:1803.00933, 2018.   \n[34] Allan Jabri, Kyle Hsu, Abhishek Gupta, Ben Eysenbach, Sergey Levine, and Chelsea Finn. Unsupervised curricula for visual meta-reinforcement learning. In Advances in Neural Information Processing Systems, pages 10519–10531, 2019.   \n[35] Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models. arXiv preprint arXiv:2001.08361, 2020.   \n[36] Steven Kapturowski, Georg Ostrovski, John Quan, Remi Munos, and Will Dabney. Recurrent experience replay in distributed reinforcement learning. In ICLR, 2019.   \n[37] Michael Kearns and Satinder Singh. Near-optimal reinforcement learning in polynomial time. Machine learning, 2002.   \n[38] Ilya Kostrikov, Denis Yarats, and Rob Fergus. Image augmentation is all you need: Regularizing deep reinforcement learning from pixels. In ICLR, 2021.   \n[39] Lisa Lee, Benjamin Eysenbach, Emilio Parisotto, Eric Xing, Sergey Levine, and Ruslan Salakhutdinov. Efficient exploration via state marginal matching. arXiv preprint arXiv:1906.05274, 2019.   \n[40] Hao Liu and Pieter Abbeel. Behavior from the void: Unsupervised active pre-training. arXiv preprint arXiv:2103.04551, 2021.   \n[41] Yao Liu and Emma Brunskill. When simple exploration is sample efficient: Identifying sufficient conditions for random exploration to yield pac rl algorithms. arXiv preprint arXiv:1805.09045, 2018.   \n[42] Shakir Mohamed and Danilo Jimenez Rezende. Variational information maximisation for intrinsically motivated reinforcement learning. In NeurIPS, 2015.   \n[43] Mirco Mutti, Lorenzo Pratissoli, and Marcello Restelli. Task-agnostic exploration via policy gradient of a non-parametric state entropy estimate. In AAAI, 2021.   \n[44] Ian Osband, Charles Blundell, Alexander Pritzel, and Benjamin Van Roy. Deep exploration via bootstrapped dqn. arXiv preprint arXiv:1602.04621, 2016.   \n[45] Ian Osband, Benjamin Van Roy, and Zheng Wen. Generalization and exploration via randomized value functions. In ICML, 2016.   \n[46] Deepak Pathak, Pulkit Agrawal, Alexei A Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In ICML, 2017.   \n[47] Adrià Puigdomènech Badia, Bilal Piot, Steven Kapturowski, Pablo Sprechmann, Alex Vitvitskyi, Daniel Guo, and Charles Blundell. Agent57: Outperforming the atari human benchmark. In ICML, 2020.   \n[48] Adrià Puigdomènech Badia, Pablo Sprechmann, Alex Vitvitskyi, Daniel Guo, Bilal Piot, Steven Kapturowski, Olivier Tieleman, Martín Arjovsky, Alexander Pritzel, Andew Bolt, et al. Never give up: Learning directed exploration strategies. In ICLR, 2020.   \n[49] Martin L Puterman. Markov Decision Processes: Discrete Stochastic Dynamic Programming. John Wiley & Sons, Inc., 1994.   \n[50] Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. OpenAI Blog, 2019.   \n[51] Christoph Salge, Cornelius Glackin, and Daniel Polani. Empowerment – an introduction. In Guided Self-Organization: Inception. Springer, 2014.   \n[52] Max Schwarzer, Nitarshan Rajkumar, Michael Noukhovitch, Ankesh Anand, Laurent Charlin, R Devon Hjelm, Philip Bachman, and Aaron Courville. Pretraining reward-free representations for data-efficient reinforcement learning. In Self-Supervision for Reinforcement Learning Workshop - ICLR 2021, 2021. URL https://openreview.net/forum?id $\\underset { . } { = }$ o5z9Le5drua.   \n[53] Ramanan Sekar, Oleh Rybkin, Kostas Daniilidis, Pieter Abbeel, Danijar Hafner, and Deepak Pathak. Planning to explore via self-supervised world models. In ICML, 2020.   \n[54] Adam Stooke, Kimin Lee, Pieter Abbeel, and Michael Laskin. Decoupling representation learning from reinforcement learning. arXiv preprint arXiv:2009.08319, 2020.   \n[55] Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.   \n[56] Richard S Sutton, Doina Precup, and Satinder Singh. Between mdps and semi-mdps: A framework for temporal abstraction in reinforcement learning. Artificial intelligence, 1999.   \n[57] Gandhimohan M Viswanathan, V Afanasyev, SV Buldyrev, EJ Murphy, PA Prince, and H Eugene Stanley. Lévy flight search patterns of wandering albatrosses. Nature, 1996.   \n[58] Ziyu Wang, Tom Schaul, Matteo Hessel, Hado Hasselt, Marc Lanctot, and Nando Freitas. Dueling network architectures for deep reinforcement learning. In ICML, 2016.   \n[59] Denis Yarats, Rob Fergus, Alessandro Lazaric, and Lerrel Pinto. Reinforcement learning with prototypical representations. In ICML, 2021.   \n[60] Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? arXiv preprint arXiv:1411.1792, 2014.   \n[61] Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In ECCV, 2014. ",
+        "bbox": [
+            155,
+            71,
+            828,
+            917
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            166,
+            42,
+            828,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            168,
+            89,
+            828,
+            916
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            163,
+            90,
+            826,
+            198
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            223,
+            254,
+            239
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The checklist follows the references. Please read the checklist guidelines carefully for information on how to answer these questions. For each question, change the default [TODO] to [Yes] , [No] , or [N/A] . You are strongly encouraged to include a justification to your answer, either by referencing the appropriate section of your paper or providing a brief inline description. For example: ",
+        "bbox": [
+            174,
+            255,
+            825,
+            311
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "• Did you include the license to the code and datasets? [No] The code and the data are proprietary. ",
+        "bbox": [
+            214,
+            321,
+            823,
+            351
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Please do not modify the questions and only use the provided macros for your answers. Note that the Checklist section does not count towards the page limit. In your paper, please delete this instructions block and only keep the Checklist section heading above along with the questions/answers below. ",
+        "bbox": [
+            140,
+            362,
+            826,
+            405
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            417,
+            339,
+            431
+        ],
+        "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]   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            436,
+            825,
+            529
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            532,
+            493,
+            547
+        ],
+        "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": [
+            235,
+            553,
+            736,
+            583
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            588,
+            393,
+            603
+        ],
+        "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)? [No] We did not include source code because it relies on non-public libraries that are specific to our distributed hardware setting. However, we include all the details needed to replicate our experiments.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] All our experiments were run with three different random seeds. Plots report mean, min and max results. Tables report mean and standard deviation.   \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": [
+            235,
+            608,
+            826,
+            796
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            217,
+            800,
+            823,
+            815
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [N/A]   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] ",
+        "bbox": [
+            235,
+            819,
+            826,
+            912
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            235,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            123,
+            707,
+            138
+        ],
+        "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,
+            142,
+            826,
+            232
+        ],
+        "page_idx": 13
+    }
+]

parse/train/rdT5GV-LnZU/rdT5GV-LnZU.md

@@ -0,0 +1,529 @@
+# Not All Attention Is All You Need
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Beyond the success story of pre-trained language models (PrLMs) in recent natu  
+2 ral language processing, they are susceptible to over-fitting due to unusual large   
+3 model size. To this end, dropout serves as a therapy. However, existing methods   
+4 like random-based, knowledge-based and search-based dropout are more general   
+5 but less effective onto self-attention based models, which are broadly chosen as   
+6 the fundamental architecture of PrLMs. In this paper, we propose a novel dropout   
+7 method named AttendOut to let self-attention empowered PrLMs capable of more   
+8 robust task-specific tuning. We demonstrate that state-of-the-art models with elab  
+9 orate training design may achieve much stronger results. We verify the universal  
+10 ity of our approach on extensive natural language processing tasks.
+
+# 11 1 Introduction
+
+12 Self-attention network (SAN) empowered models like Transformer [1] have achieved remarkable   
+13 success in recent natural language processing, which have been broadly chosen as basic architec  
+14 ture in a series successful pre-trained language models (PrLMs) such as BERT [2], RoBERTa [3],   
+15 ALBERT [4], ELECTRA [5], DeBERTa [6] and GPT [7].   
+16 SAN has drawn a great deal of curiosity on its conceptually simple but powerful attention mecha  
+17 nism. However, SAN still remains a black box and more and more works attempt to unveil its inner   
+18 principle, where the biggest mystery lies in its attention matrix. Our work is inspired by several   
+19 recent discoveries which turn our views up and down. [8, 9] show that fixed Gaussian or even ran  
+20 dom alignment attention matrix may rival standard SAN, while more recently, [10, 11] prove that   
+21 SAN may encounter a rank collapse with deepening of layers. A more concrete explanation is in  
+22 formation diffusion [12], which states that the input vectors are progressively assimilating through   
+23 continuously making self-attention. We attribute these problems to the sever co-adaption [13] be  
+24 tween attention elements, a form of over-fitting onto SAN. As a result, self-attention empowered   
+25 PrLMs hardly bring into their full play, especially for the fine-tuning stage, where task-specific data   
+26 is always with limited capacity.   
+27 Dropout [13] serves as a therapy to deal with the problem, by randomly shutting down a set of units   
+28 during training stage. When specified on self-attention, dropout is equivalent to adding attention   
+29 mask to the attention matrix. However, random-based dropout methods like vanilla Dropout [13] or   
+30 DropConnect [14] are all subject to a pre-defined distribution like Bernoulli or Gaussian, longing for   
+31 exhaustive grid search for an optimal probability. Thereby a variety of works attempt to utilize man  
+32 ual attention mask to obtain a more informative attention matrix [15, 16], whereas all these methods   
+33 require prior knowledge on model or data, which could be costly or unavailable. More recently, the   
+34 rise of Neural Architecture Search [17, 18] gives birth to search-based dropout [19], which automat  
+35 ically chooses an optimal dropout pattern based on additional validation performances. However,   
+36 the huge search space brings heavy consumption and more importantly, the obtained dropout pattern   
+37 is still fixed with a pre-defined probability, which is static and sample-independent, ignoring the   
+38 dynamics within different samples. In this paper, we focus on task-specific tuning of self-attention   
+39 empowered PrLMs and propose a novel dropout method named AttendOut onto attention layers,   
+40 which leverages self-attention to dynamically generate dropout patterns for each attention layer as   
+41 well as each sample through an end-to-end manner. We demonstrate that the previous state-of-the-art   
+42 models with elaborate training design may achieve much stronger results. We verify the universality   
+43 of our approach on extensive natural language processing tasks. Guided by AttendOut, we pro  
+44 pose another two attention regularizers to enable simple but effective performance boost with no   
+45 additional cost.
+
+![](images/bb9e5c7dfb1c536808b7a53013b509ca9c34d20afb292d3c61b86cbda7d324d9.jpg)  
+Figure 1: A diagram of different dropout methods, where $p$ refers to the dropout probabilities while $R$ refers to the reward in reinforcement learning.
+
+# 46 2 Related Work
+
+47 Dropout is proposed to alleviate over-fitting problem in DNNs. Apart from vanilla Dropout [13]   
+48 and DropConnect [14] which randomly shut down a subset of activations or hidden weights, there   
+49 are a variety of dropout methods proposed, e.g. Alpha Dropout [20], Variational Dropout [21, 22],   
+50 Adversarial Dropout [23], Energy-based Dropout [24]. However, random-based dropout encounters   
+51 slow experiment cycle due to inevitable grid search. Inspired by Neural Architecture Search [17, 18],   
+52 [19] proposes AutoDropout to automate the process of designing dropout patterns. A similar line of   
+53 work is dynamic tuning of dropout, which further allows adaptive dropout probabilities under differ  
+54 ent training moments. [25] proposes Concrete Dropout with continuous relaxation under Concrete   
+55 distribution, [26] proposes Learnable Bernoulli Dropout under discrete Bernoulli distribution using   
+56 Augment-REINFORCE-Merge estimator [27], while [28] proposes Context Dropout by optimizing   
+57 the evidence lower bound.   
+58 With self-attention network continuously stands out, dropout is being explored onto self-attention   
+59 based models. LayerDrop [29] randomly removes entire SAN blocks, while DropHead [30], Head  
+60 Mask [31] randomly remove certain attention heads. UniDrop [32] unifies these dropout methods,   
+61 which facilitates text classification and machine translation tasks. Additionally, prior knowledge is   
+62 shown highly effective for guiding attention dropout as in SG-Net [15] and SIT [16], which inten  
+63 tionally discard syntax-unrelated attention units with the help of structural clues.
+
+# 64 3 Preliminaries
+
+65 In this section, we provide the preliminaries for the proposed approach. We first review the details   
+66 of self-attention proposed in [1]. Based on the specific architecture, we elaborate the concerned   
+67 attention dropout.
+
+# 3.1 Self-Attention
+
+69 Generally, a standard SAN block is mainly composed of an attention layer and several feed-forward   
+70 layers (actually there are residual connection, layer normalization, etc. as well). The input of it is a   
+71 sentence or batch of sentences of length $n$ , which is first embedded through an embedding layer. The   
+72 embedded input $E$ may go through three linear projections $W _ { Q }$ , $W _ { K }$ and $W _ { V }$ referring to query, key   
+73 and value layers respectively, and then obtain three matrices $Q$ , $K$ and $V$ referring to the query, key   
+74 and value components of self-attention. Subsequently, a dot-product of $Q$ and $K$ is taken and then   
+75 normalized using Sof tmax function to obtain the attention matrix $A$ . Then another dot-product of   
+76 $A$ and $V$ follows. The mentioned calculation can be formalized as follow:
+
+$$
+A t t e n t i o n ( Q , K , V ) = S o f t m a x \left( \frac { Q \cdot K ^ { T } } { \sqrt { d _ { k } } } \right) \cdot V
+$$
+
+where 77 $\sqrt { d _ { k } }$ is a scaling factor. Finally, the self-attention layer ends up with a linear projection $W _ { O }$ 78 to output.
+
+79 During the aforementioned process, we highlight a key phases, that is the attention matrix $A$ , which   
+80 is a dot-product of $n \times n$ from two separate linear projections $W _ { Q }$ and $W _ { K }$ . $A$ is viewed as a feature   
+81 map which stores the node-to-node significance in different scores. Various works show that there   
+82 hides implicit but highly needed semantic clues.
+
+# 3.2 Dropout on Self-Attention
+
+84 Our dropout will apply to the attention matrix of the concerned attention layer. We first define two   
+85 specific dropouts onto Eq. 1, where both implementations are just as simple as in standard dropout   
+86 via a mask matrix $M$ .
+
+Weights Dropout. Weights dropout is applied to the attention matrix after Sof tmax function by default, which is formulated as:
+
+$$
+{ \cal A } t t e n t i o n ( Q , K , V ) = \left( S o f t m a x \left( { \frac { Q \cdot K ^ { T } } { \sqrt { d _ { k } } } } \right) \odot { \cal M } \right) \cdot V
+$$
+
+9 where $M$ is a binary matrix with elements in $\{ 0 , 1 \}$ and $\odot$ refers to element-wise multiplication.
+
+90 Scores Dropout. Different from weights dropout, scores dropout is applied before Sof tmax func  
+91 tion, which is formulated as:
+
+$$
+A t t e n t i o n ( Q , K , V ) = S o f t m a x \left( \frac { Q \cdot K ^ { T } } { \sqrt { d _ { k } } } + M \right) \cdot V
+$$
+
+92 Since the outer Sof tmax, we conduct an addition instead of multiplication, where elements in $M$   
+93 are set to 0 for kept units and $- i n f$ for removed ones. Note that the Sof tmax takes a similar   
+94 function as the scaling factor of $1 / p$ in vanilla Dropout [13], which balances the expectation of the   
+95 network.   
+96 Weights dropout is commonly used in self-attention based models, while scores dropout is less   
+97 explored, which is our focus in this paper. For scores dropout, we need to pay attention to a special   
+98 case, when all attentions are shut down, that is, all elements in $M$ equal to $- i n f$ at the same time.   
+99 Such case can be formulated as follow:
+
+$$
+A t t e n t i o n ( Q , K , V ) = S o f t m a x \left( M \right) \cdot V
+$$
+
+100 Note that Sof tmax $( M )$ obtains to a constant matrix, where each unit equals to $1 / n$ . In this case,   
+101 the attention matrix is fixed and consequently the $W _ { Q }$ , $W _ { K }$ and dot-product in between are skipped.
+
+# 102 4 Methodology
+
+103 In this paper, we propose Attention differentiable dropOut (AttendOut), which contributes technique   
+104 novelty in the following way: (1) dynamic and task-specific tuned; (2) end-to-end trained; (3) gra  
+105 dient optimized dropout method onto self-attention empowered PrLMs. We elaborate our approach   
+106 with two parts, in which the first is composition, while the second is training algorithm.
+
+# 4.1 Elements of AttendOut
+
+108 Our training architecture is composed of three modules, A-Net (Attacker), D-Net (Defender) and   
+109 G-Net (Generator). D-Net and A-Net are two identical models and trained simultaneously through   
+110 standard gradient descent, while G-Net is a learnable dropout maker and trained through policy   
+111 gradient. Now we elaborate each of them.   
+112 Defender - Attacker As suggested, defender and attacker are two competitors playing a game   
+113 with each other on specific criteria, e.g. training accuracy, training loss. Specifically, D-Net and A  
+114 Net are two identical self-attention empowered PrLMs, e.g. BERT, RoBERTa. However, they follow   
+115 different dropout strategies. D-Net receives regular dropout as default in specific models, while A  
+116 Net receives additional dropout decision from G-Net onto its corresponding attention layers.   
+117 Generator G-Net acts as a dropout maker through generating a mask matrix for each attention   
+118 layer during training stage. As aforementioned, the common dropout strategies rely on randomness,   
+119 which intends to shut down the co-adaption but not powerful enough. However, our dropout maker   
+120 is an agent which is able to intelligently choose and learn dropout patterns for each sample. Specif  
+121 ically, after training for a fixed number of steps, we conduct evaluation for both A-Net and D-Net.   
+122 When A-Net obtains a higher score than D-Net, which means attacker wins the game, G-Net will be   
+123 rewarded positively. When defender wins, G-Net will be punished with a negative reward. In con  
+124 sequence, G-Net learns appropriate dropout patterns through the game between D-Net and A-Net,   
+125 while assisting A-Net to win the game. On the other hand, A-Net needs to be stronger when training   
+126 under such powerful dropout, which makes it much more robust from over-fitting. Compared to   
+127 search-based dropout, G-Net is triggered by the difference between two model derivatives with and   
+128 without dropout, instead of the final feedback on validation set, which makes it end-to-end-possible   
+129 and sample-dependent.   
+130 The design of G-Net is the most delicate part, which is also a self-attention based model with iden  
+131 tical number of layers with D-Net and A-Net. However, we make several improvements. 1) G-Net   
+132 only exports the attention scores from attention layers with no extra output layers, from which we   
+133 apply Gumbel [33, 34] to sample the actions to obtain the dropout mask. 2) G-Net only makes   
+134 one-head attention and share one group of parameters for all attention layers. 3) G-Net is excluded   
+135 of feed-forward layers, which may obscure the impact of self-attention [11, 10].
+
+# 4.2 Training with AttendOut
+
+37 The core of training with AttendOut is to find a way to optimize G-Net, which receives signals from   
+38 the difference between D-Net and A-Net. Supposing there is a list of dropout actions by G-Net:
+
+$$
+a _ { 1 : T } = \{ a _ { 1 } , a _ { 2 } , a _ { 3 } , \cdot \cdot \cdot , a _ { T } \}
+$$
+
+139 where $T$ refers to the number of samples, for each action $a _ { t }$ , G-Net may achieve a reward $r _ { t }$ . The   
+140 optimization objective is to maximize the overall rewards of list $a _ { 1 : T }$ , denoted as $R$ , that is:
+
+$$
+J ( \theta _ { G } ) = E _ { P ( a _ { 1 : T } ; \theta _ { G } ) } [ R ]
+$$
+
+where 141 $\begin{array} { r } { R = \sum _ { t = 1 } ^ { T } r _ { t } } \end{array}$ . Since $R$ is non-differentiable, we use policy gradient to update $\theta _ { G }$
+
+$$
+\nabla _ { \theta _ { G } } J ( \theta _ { G } ) = \sum _ { t = 1 } ^ { T } E _ { P ( a _ { 1 : T } ; \theta _ { G } ) } [ \nabla _ { \theta _ { G } } \log P ( a _ { t } | a _ { ( t - 1 ) : 1 } ; \theta _ { G } ) r _ { t } ]
+$$
+
+142 The above equation could be approximated as:
+
+$$
+\frac { 1 } { m } \sum _ { k = 1 } ^ { m } \sum _ { t = 1 } ^ { T } \nabla _ { \theta _ { G } } \log P ( a _ { t } | a _ { ( t - 1 ) : 1 } ; \theta _ { G } ) r _ { t }
+$$
+
+143 For a model with $n$ attention layers, each dropout decision is composed of $n$ inner decisions of each   
+144 layer. Additionally, each attention layer contains an attention matrix of $l \times l$ , namely $l ^ { 2 }$ elements   
+145 dropped or kept. Thus, we denote a dropout unit as $d ^ { i j }$ , where $i$ refers to the $i ^ { t h }$ layer while $j$ refers   
+146 to the $j ^ { t h }$ element of the attention matrix.   
+147 However, $n l ^ { 2 }$ dropout units bring a huge space, which makes it impossible to calculate the joint prob  
+148 ability. To this end, we introduce the independence assumption that each dropout unit is independent   
+149 with each other. Under the relaxation, we can make the following probability likelihood:
+
+$$
+\log P ( a _ { t } | a _ { ( t - 1 ) : 1 } ; \theta _ { G } ) = \frac { 1 } { n l ^ { 2 } } \sum _ { i , j } \log P ( d _ { t } ^ { i j } | d _ { ( t - 1 ) : 1 } ^ { i j } ; \theta _ { G } )
+$$
+
+where the summation 150 $\textstyle \sum _ { i = 1 } ^ { n } \sum _ { j = 1 } ^ { l ^ { 2 } }$ is briefly denoted as $\textstyle \sum _ { i , j }$
+
+151 Thus, the final gradient could be formalized as:
+
+$$
+\nabla _ { \theta _ { G } } J ( \theta _ { G } ) = \frac { 1 } { m } \frac { 1 } { n l ^ { 2 } } \sum _ { k = 1 } ^ { m } \sum _ { t = 1 } ^ { T } \sum _ { i , j } \nabla _ { \theta _ { G } } \log P ( d _ { t } ^ { i j } | d _ { ( t - 1 ) : 1 } ^ { i j } ; \theta _ { G } ) ( r _ { t } - b )
+$$
+
+152 where $b$ is a baseline function of moving average [35]. Note that we do not apply additional regular  
+153 izers like L0 and L1 penalty, which impose unnecessary bias.   
+154 Algorithm 1 summarizes the overall procedure of training PrLMs with AttendOut. We first initialize   
+155 all three networks. Note that D-Net and A-Net should be kept identical at the beginning of each   
+156 training step. A straightforward strategy is to choose the better one to cover the other. To add   
+157 randomness, we sample from D-Net and A-Net based on their evaluation performances, with higher   
+158 probability for the better one. Then for each step, D-Net and A-Net are fed with the same mini-batch   
+159 data and updated via standard gradient descent, meanwhile each batch will be cached. After training   
+160 for $T$ steps, which we denote as a dropout step, both D-Net and A-Net are evaluated on additional   
+161 validation samples, which could be development set data, noisy training data or a small split of train  
+162 ing data. In this paper, we simply use development set. For efficiency, we make random sampling   
+163 on it to retrieve $T$ samples for evaluation. Based on the evaluation scores, G-Net is rewarded with   
+164 $\{ r _ { 1 } , r _ { 2 } , r _ { 3 } , \cdot \cdot \cdot , r _ { T } \}$ and updated via Eq. 5. At the end of each dropout step, the cached samples   
+165 will be released and D-Net and A-Net will be re-initialized.
+
+# Algorithm 1 AttendOut
+
+Input: Attacker $A$ , Defender $D$ , Generator $G$ , dropout   
+step $T$   
+1: initialize $\theta _ { D }$ , $\theta _ { A }$ , $\theta _ { G }$ , where $\theta _ { D } = \theta _ { A }$   
+2: for each training step do   
+3: $\theta _ { D }  \theta _ { D } ^ { \prime }$   
+4: dropout $A$ with $G$ via Eq. 3   
+5: $\theta _ { A }  \theta _ { A } ^ { \prime }$   
+6: for each $T$ steps do   
+7: evaluate $D$ and $A$ and reward $G$   
+8: $\theta _ { G }  \theta _ { G } ^ { \prime }$ via Eq. 5   
+9: initialize $\theta _ { D }$ , $\theta _ { A }$ for next step   
+10: end for   
+11: end for   
+167 Resource Usage We notice that training PrLMs with AttendOut may sacrifice time and memory   
+168 cost. The detailed resource usage is shown in Appendix. Taking RoBERTa as an example, the   
+169 algorithm requires two RoBERTa models as well as a smaller self-attention based generator, which   
+170 is $\mathrm { { \bar { 1 } / 3 } }$ of RoBERTa size. Considering cached samples, roughly speaking, AttendOut requires twice   
+171 graphic memory as well as twice training time compared to a single model, which is a middle speed   
+172 line between random-based dropout and neural architecture search (Dropout [13] $<$ AttendOut $\ll$   
+173 AutoDropout [19]). However, AttendOut contributes to remarkable performance gain compared to   
+174 other attention dropout methods.   
+175 Pre-training Our approach is both feasible for both fine-tuning and pre-training stage of PrLMs   
+176 but expensive for the latter. However, we try to serve for the most delicate part of concerned issue,   
+177 since pre-training is generally done on large-scale data with modest training epochs, which makes it   
+178 less susceptible from over-fitting.
+
+![](images/fd257beb2fcc68132803a55e565d83d523ed0eecbb7ad908e1916676d82e7134.jpg)  
+Figure 2: Architecture of G-Net.
+
+Table 1: Results (test / dev) of GLUE sub-tasks.   
+
+<table><tr><td>Model</td><td>SST-2 Acc</td><td>MRPC F1</td><td>QNLI Acc</td><td>MNLI-mm Acc</td><td>CoLA Mcc</td></tr><tr><td>BERT</td><td>92.9 / 92.2</td><td>86.6 / 86.3</td><td>89.7 /88.9</td><td>83.3 /84.0</td><td>51.2 / 58.8</td></tr><tr><td>+ AtendOut</td><td>93.6 / 93.8</td><td>88.1 / 87.5</td><td>90.2 / 91.1</td><td>84.2 /84.6</td><td>57.4 / 60.9</td></tr><tr><td>RoBERTa</td><td>95.4 / 94.4</td><td>90.5 /90.2</td><td>92.9 /92.0</td><td>86.1 /86.6</td><td>61.3 / 62.5</td></tr><tr><td>+ AtendOut</td><td>96.2 / 95.1</td><td>91.2 / 90.9</td><td>93.3 /93.0</td><td>87.3 /87.8</td><td>63.0 / 63.8</td></tr></table>
+
+Table 2: Results of IMDB, CoNLL03, PTB and SWAG respectively.   
+
+<table><tr><td>Model</td><td>IMDB Acc</td><td>CoNLL03 F1</td><td>PTB F1</td><td>SWAG Acc</td></tr><tr><td>BERT</td><td>92.2</td><td>94.1</td><td>95.4</td><td>81.1</td></tr><tr><td>+ AttendOut</td><td>92.9</td><td>94.7</td><td>96.5</td><td>81.6</td></tr><tr><td>RoBERTa</td><td>93.6</td><td>94.5</td><td>96.6</td><td>83.8</td></tr><tr><td>+ AttendOut</td><td>94.2</td><td>95.2</td><td>97.3</td><td>84.1</td></tr></table>
+
+# 179 5 Experimental Setup
+
+180 We demonstrate the universal effectiveness of AttendOut on extensive natural language processing   
+181 tasks. For all mentioned tasks, we apply our method on BERT [2] and its stronger variant RoBERTa   
+182 [3]. Our implementations are based on PyTorch using transformers [36]. For further training details,   
+183 please refer to Appendix.   
+184 Our experiments include: (1) natural language understanding: General Language Understanding   
+185 Evaluation (GLUE) benchmark [37], a collection of nine natural language understanding tasks (here   
+186 we experiment on five of them, SST-2, MRPC, QNLI, MNLI-mm and CoLA; (2) document clas  
+187 sification: IMDB [38], a sentiment analysis dataset where about $15 \%$ of the documents are longer   
+188 than 512 word-pieces; (3) named entity recognition: CoNLL2003 [39]; (4) part-of-speech tag  
+189 ging: English Penn Treebank (PTB) [40]; (5) multiple choices question answering: SWAG [41].   
+190 We report both test and development results for GLUE sub-tasks since the large bias between them,   
+191 while development results only for all the other tasks.   
+192 Note that we only adjust the dropout steps and keep all other parameters the same for strict fair   
+193 comparison. For example, the parameters we use in RoBERTa are identical with what we use in   
+194 training with AttendOut including both D-Net and A-Net.
+
+# 6 Results
+
+# 6.1 Significance Analysis
+
+97 Pictorially in Table 1, RoBERTa is strong enough as it outperforms BERT by a big margin, while   
+98 AttendOut empowered RoBERTa still outperforms it on all five GLUE sub-tasks. For small-scale   
+99 datasets, which are more likely to over-fit, AttendOut helps unfold remarkable performance gain   
+00 $( 1 2 . 1 \% \ / \ 3 . 5 \%$ over BERT on CoLA, $1 . 7 \% / 1 . 4 \%$ over BERT on MRPC). However, for large  
+01 scale one like MNLI, which tends to be more stable, AttendOut still produces considerable boost,   
+02 $( 1 . 4 \% / 1 . 4 \%$ over RoBERTa, $1 . 1 \% / 0 . 7 \%$ over BERT).   
+203 Furthermore, AttendOut is shown universally effective as in Table 2. For POS Tagging, BERT   
+204 and RoBERTa have achieved very strong baselines, while AttendOut empowered ones are even   
+205 stronger, $3 . 1 \%$ over BERT on PTB). Similar results are seen on document classification and NER.   
+206 For SWAG, however, AttendOut seems weakly effective $\mathbf { 0 . 6 \% }$ over BERT, $0 . 4 \%$ over RoBERTa).
+
+![](images/5fb2129c880eb1d2bbb3f4e477445ad7dac156a1c0699af1632c637d63bc4d20.jpg)  
+Figure 3: Dropout probabilities on specific attention layers over training steps.
+
+![](images/3195061f460620f90c7af6ac43fe036d69fcbd8c0b3dc54487b440d5ed05c143.jpg)  
+Figure 4: Convergence over training epochs.
+
+# 207 6.2 Visual Analysis
+
+Dropout Patterns Another concerned issue is the dropout proportions by AttendOut. Figure 3 depicts the patterns on several datasets. We may find several interesting phenomenons. First, the overall patterns largely differ from datasets, which is fair since AttendOut is sample-dependent. However, we may observe something in common. Overall, the lower layers take higher dropout probabilities. For example on QNLI, the first layer almost remains steady with the probability of 0.55 during the training process, while the fourth one continuously decays in a higher rate. Intuitively, the first three layers undertake a similar trend in each dataset, while there might be an up and down for the fourth one as in SST-2 and CoLA. Especially for CoLA, we see unusual high dropout probabilities in the final period (around 0.9), which are close to complete dropout. We notice that CoLA is a small set with 8500 training samples, on which SAN model is more inclined to suffer from over-fitting. Therefore, PrLM on CoLA encounters more intensive dropout through AttendOut.
+
+219 Convergence Figure 4 depicts the accuracy trends of RoBERTa on SST-2, QNLI, MNLI respec  
+220 tively. Due to a stronger dropout module, the one with AttendOut tends to fall behind (SST-2,   
+221 MNLI) at the beginning of training. However, model becomes stronger since the second epoch   
+222 (SST-2, QNLI). Especially on MNLI, RoBERTa obtains better results in the first two epochs and it   
+223 drops in the last one, while with AttendOut, the performance is steadily rising for all three epochs.
+
+# 7 Ablation Study
+
+In this section, we conduct further experiments to demonstrate the effectiveness of AttendOut. Due to space limitation, we conduct corresponding experiments on development sets only.
+
+# 7.1 Attention Dropout
+
+Vanilla Dropout We conduct comparison with vanilla Dropout [13], in which we dropout the attention matrix for all layers with Bernoulli distribution of $p$ . Here, we choose the dropout probabilities in {0.1, 0.2}.
+
+Table 3: Comparison of AttendOut, vanilla Dropout and LayerDrop.   
+
+<table><tr><td>Model</td><td>CoLA</td><td>QNLI</td><td>MNLI-mm</td></tr><tr><td>RoBERTa</td><td>62.5</td><td>92.0</td><td>86.6</td></tr><tr><td>+ Vanilla</td><td>61.3</td><td>92.2</td><td>86.9</td></tr><tr><td>+ AttendOut</td><td>63.8</td><td>93.1</td><td>87.8</td></tr><tr><td>+ LayerDrop</td><td>62.1</td><td>92.6</td><td>87.1</td></tr><tr><td>+ Attn.LayerDrop</td><td>64.2</td><td>92.7</td><td>87.3</td></tr></table>
+
+Table 4: Comparison of AttendOut and scheduled Bernoulli dropout.   
+
+<table><tr><td>Model</td><td>CoLA</td><td>QNLI</td><td>SWAG</td></tr><tr><td>RoBERTa</td><td>62.5</td><td>92.0</td><td>83.8</td></tr><tr><td>+ Scheduler</td><td>63.3</td><td>92.6</td><td>83.6</td></tr><tr><td>+ AttendOut</td><td>63.8</td><td>93.1</td><td>84.1</td></tr></table>
+
+231 LayerDrop We also compare with LayerDrop [29], which focuses on skipping the entire encoder   
+232 blocks, Inspired of it, we design another strategy which randomly skips attention layers via Eq. 4.   
+233 For fair enough comparison, we set the dropout probabilities to 0.2 for both methods, following the   
+234 settings in [29].   
+235 Intuitively in Table 3, vanilla Dropout with fixed probability does not produce noticeable gain $( 1 . 9 \%$   
+236 bellow RoBERTa on CoLA). However, AttendOut shows powerful advantage $4 . 1 \%$ , $1 . 0 \%$ and $1 . 0 \%$   
+237 over vanilla Dropout on CoLA, QNLI and MNLI), which stresses the necessity of dynamic dropout   
+238 patterns rather than fixed static one. On the other hand, both layer-level regularizers are effective,   
+239 while attention LayerDrop performs stronger and more stable on all the three. Especially on CoLA,   
+240 it outperforms RoBERTa by 1.7 points, while LayerDrop meets a performance drop, which demon  
+241 strates that removing the attention layers act as a more effective regularizer than removing the entire   
+242 SAN block as for self-attention based models.
+
+# 243 7.2 Pattern Approximation
+
+244 Guided by AttendOut, we design a dropout scheduler, in which we utilize piece-wise linearity to   
+245 approximate the real curves as depicted in Figure 3. Taking QNLI as an example, we initialize   
+246 the dropout probabilities to 0.6 for all attention layers and set a a specific slope for each of them.   
+247 Note that here the corresponding mask matrices are randomly-generated and subject to Bernoulli   
+248 distribution. In AttendOut, however, the distribution are learned dynamically through self-attention   
+249 of G-Net.   
+250 As shown in Table 4, RoBERTa with scheduled Bernoulli dropout works surprisingly well on both   
+251 CoLA and QNLI, which outperforms RoBERTa by 0.8 and 0.6 points respectively, closer to At  
+252 tendOut, even if the strategy here is random-based and much looser. The guided scheduled dropout   
+253 helps unfold the correctness of the dynamic dropout patterns learned by AttendOut as well as the   
+254 self-attention based dropout maker.
+
+# 255 8 Conclusion
+
+This paper focuses on the co-adaption problem of deep self-attention networks, and presents a novel dropout method onto self-attention empowered pre-trained language models. Extensive experiments on multiple natural language processing tasks demonstrate that our proposed approach is universal and qualified to enable more robust task-specific tuning, which contributes to much stronger stateof-the-arts. We probe into the learned dropout patterns on different tasks, which empirically guide us to the very needed dynamic attention dropout design.
+
+262 References   
+263 [1] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz   
+264 Kaiser, and Illia Polosukhin. Attention is all you need. In Isabelle Guyon, Ulrike von Luxburg, Samy   
+265 Bengio, Hanna M. Wallach, Rob Fergus, S. V. N. Vishwanathan, and Roman Garnett, editors, Advances   
+266 in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing   
+267 Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 5998–6008, 2017.   
+268 [2] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: pre-training of deep bidi  
+269 rectional transformers for language understanding. In Jill Burstein, Christy Doran, and Thamar Solorio,   
+270 editors, Proceedings of the 2019 Conference of the North American Chapter of the Association for Com  
+271 putational Linguistics: Human Language Technologies, NAACL-HLT 2019, Minneapolis, MN, USA, June   
+272 2-7, 2019, Volume 1 (Long and Short Papers), pages 4171–4186. Association for Computational Linguis  
+273 tics, 2019.   
+274 [3] Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis,   
+275 Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized BERT pretraining approach.   
+276 CoRR, abs/1907.11692, 2019.   
+277 [4] Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut.   
+278 ALBERT: A lite BERT for self-supervised learning of language representations. In 8th International   
+279 Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. Open  
+280 Review.net, 2020.   
+281 [5] Kevin Clark, Minh-Thang Luong, Quoc V. Le, and Christopher D. Manning. ELECTRA: pre-training   
+282 text encoders as discriminators rather than generators. In 8th International Conference on Learning Rep  
+283 resentations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   
+284 [6] Pengcheng He, Xiaodong Liu, Jianfeng Gao, and Weizhu Chen. {DEBERTA}: {DECODING}-   
+285 {enhanced} {bert} {with} {disentangled} {attention}. In International Conference on Learning Repre  
+286 sentations, 2021.   
+287 [7] Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding   
+288 by generative pre-training. 2018.   
+289 [8] Weiqiu You, Simeng Sun, and Mohit Iyyer. Hard-coded gaussian attention for neural machine translation.   
+290 In Dan Jurafsky, Joyce Chai, Natalie Schluter, and Joel R. Tetreault, editors, Proceedings of the 58th   
+291 Annual Meeting of the Association for Computational Linguistics, ACL 2020, Online, July 5-10, 2020,   
+292 pages 7689–7700. Association for Computational Linguistics, 2020.   
+293 [9] Yi Tay, Dara Bahri, Donald Metzler, Da-Cheng Juan, Zhe Zhao, and Che Zheng. Synthesizer: Rethinking   
+294 self-attention in transformer models. CoRR, abs/2005.00743, 2020.   
+295 [10] Sinong Wang, Belinda Z. Li, Madian Khabsa, Han Fang, and Hao Ma. Linformer: Self-attention with   
+296 linear complexity. CoRR, abs/2006.04768, 2020.   
+297 [11] Yihe Dong, Jean-Baptiste Cordonnier, and Andreas Loukas. Attention is not all you need: Pure attention   
+298 loses rank doubly exponentially with depth. CoRR, abs/2103.03404, 2021.   
+299 [12] Saurabh Goyal, Anamitra Roy Choudhury, Saurabh Raje, Venkatesan T. Chakaravarthy, Yogish Sabhar  
+300 wal, and Ashish Verma. Power-bert: Accelerating BERT inference via progressive word-vector elimi  
+301 nation. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18   
+302 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 3690–3699.   
+303 PMLR, 2020.   
+304 [13] Nitish Srivastava, Geoffrey E. Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov.   
+305 Dropout: a simple way to prevent neural networks from overfitting. J. Mach. Learn. Res., 15(1):1929–   
+306 1958, 2014.   
+307 [14] Li Wan, Matthew D. Zeiler, Sixin Zhang, Yann LeCun, and Rob Fergus. Regularization of neural networks   
+308 using dropconnect. In Proceedings of the 30th International Conference on Machine Learning, ICML   
+309 2013, Atlanta, GA, USA, 16-21 June 2013, volume 28 of JMLR Workshop and Conference Proceedings,   
+310 pages 1058–1066. JMLR.org, 2013.   
+311 [15] Zhuosheng Zhang, Yuwei Wu, Junru Zhou, Sufeng Duan, Hai Zhao, and Rui Wang. Sg-net: Syntax  
+312 guided machine reading comprehension. In The Thirty-Fourth AAAI Conference on Artificial Intelligence,   
+313 AAAI 2020, The Thirty-Second Innovative Applications of Artificial Intelligence Conference, IAAI 2020,   
+314 The Tenth AAAI Symposium on Educational Advances in Artificial Intelligence, EAAI 2020, New York, NY,   
+315 USA, February 7-12, 2020, pages 9636–9643. AAAI Press, 2020.
+
+[16] Hongqiu Wu, Hai Zhao, and Min Zhang. Code summarization with structure-induced transformer. arXiv preprint arXiv:2012.14710, 2020.   
+[17] Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017.   
+[18] Hanxiao Liu, Karen Simonyan, and Yiming Yang. DARTS: differentiable architecture search. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.   
+[19] Hieu Pham and Quoc V. Le. Autodropout: Learning dropout patterns to regularize deep networks. CoRR, abs/2101.01761, 2021.   
+[20] Günter Klambauer, Thomas Unterthiner, Andreas Mayr, and Sepp Hochreiter. Self-normalizing neural networks. In Isabelle Guyon, Ulrike von Luxburg, Samy Bengio, Hanna M. Wallach, Rob Fergus, S. V. N. Vishwanathan, and Roman Garnett, editors, Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 971–980, 2017.   
+[21] Avrim Blum, Nika Haghtalab, and Ariel D. Procaccia. Variational dropout and the local reparameterization trick. In Corinna Cortes, Neil D. Lawrence, Daniel D. Lee, Masashi Sugiyama, and Roman Garnett, editors, Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pages 2575–2583, 2015.   
+[22] Dmitry Molchanov, Arsenii Ashukha, and Dmitry P. Vetrov. Variational dropout sparsifies deep neural networks. In Doina Precup and Yee Whye Teh, editors, Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, volume 70 of Proceedings of Machine Learning Research, pages 2498–2507. PMLR, 2017.   
+[23] Sungrae Park, Jun-Keon Park, Su-Jin Shin, and Il-Chul Moon. Adversarial dropout for supervised and semi-supervised learning. In Sheila A. McIlraith and Kilian Q. Weinberger, editors, Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence, (AAAI-18), the 30th innovative Applications of Artificial Intelligence (IAAI-18), and the 8th AAAI Symposium on Educational Advances in Artificial Intelligence (EAAI-18), New Orleans, Louisiana, USA, February 2-7, 2018, pages 3917–3924. AAAI Press, 2018.   
+[24] Hojjat Salehinejad and Shahrokh Valaee. Edropout: Energy-based dropout and pruning of deep neural networks. CoRR, abs/2006.04270, 2020.   
+[25] Yarin Gal, Jiri Hron, and Alex Kendall. Concrete dropout. In Isabelle Guyon, Ulrike von Luxburg, Samy Bengio, Hanna M. Wallach, Rob Fergus, S. V. N. Vishwanathan, and Roman Garnett, editors, Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 3581–3590, 2017.   
+[26] Shahin Boluki, Randy Ardywibowo, Siamak Zamani Dadaneh, Mingyuan Zhou, and Xiaoning Qian. Learnable bernoulli dropout for bayesian deep learning. In Silvia Chiappa and Roberto Calandra, editors, The 23rd International Conference on Artificial Intelligence and Statistics, AISTATS 2020, 26-28 August 2020, Online [Palermo, Sicily, Italy], volume 108 of Proceedings of Machine Learning Research, pages 3905–3916. PMLR, 2020.   
+[27] Mingzhang Yin and Mingyuan Zhou. ARM: augment-reinforce-merge gradient for stochastic binary networks. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.   
+[28] Xinjie Fan, Shujian Zhang, Korawat Tanwisuth, Xiaoning Qian, and Mingyuan Zhou. Contextual dropout: An efficient sample-dependent dropout module. CoRR, abs/2103.04181, 2021.   
+[29] Angela Fan, Edouard Grave, and Armand Joulin. Reducing transformer depth on demand with structured dropout. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   
+[30] Wangchunshu Zhou, Tao Ge, Furu Wei, Ming Zhou, and Ke Xu. Scheduled drophead: A regularization method for transformer models. In Trevor Cohn, Yulan He, and Yang Liu, editors, Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: Findings, EMNLP 2020, Online Event, 16-20 November 2020, pages 1971–1980. Association for Computational Linguistics, 2020.
+
+369 [31] Zewei Sun, Shujian Huang, Xinyu Dai, and Jiajun Chen. Alleviating the inequality of attention heads for   
+370 neural machine translation. CoRR, abs/2009.09672, 2020.   
+371 [32] Zhen Wu, Lijun Wu, Meng Qi, Yingce Xia, Shufang Xie, Tao Qin, Xinyu Dai, and Tie-Yan Liu. Unidrop:   
+372 A simple yet effective technique to improve transformer without extra cost. In Proceedings of the The 2021   
+373 Conference of the North American Chapter of the Association for Computational Linguistics - Human   
+374 Language Technologies, Volume 1 (Long Papers), 2021.   
+375 [33] Chris J. Maddison, Daniel Tarlow, and Tom Minka. $\mathbf { A } ^ { * }$ sampling. In Zoubin Ghahramani, Max Welling,   
+376 Corinna Cortes, Neil D. Lawrence, and Kilian Q. Weinberger, editors, Advances in Neural Information   
+377 Processing Systems 27: Annual Conference on Neural Information Processing Systems 2014, December   
+378 8-13 2014, Montreal, Quebec, Canada, pages 3086–3094, 2014.   
+379 [34] Xinwei Geng, Longyue Wang, Xing Wang, Bing Qin, Ting Liu, and Zhaopeng Tu. How does selective   
+380 mechanism improve self-attention networks? In Dan Jurafsky, Joyce Chai, Natalie Schluter, and Joel R.   
+381 Tetreault, editors, Proceedings of the 58th Annual Meeting of the Association for Computational Linguis  
+382 tics, ACL 2020, Online, July 5-10, 2020, pages 2986–2995. Association for Computational Linguistics,   
+383 2020.   
+384 [35] Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement   
+385 learning. Mach. Learn., 8:229–256, 1992.   
+386 [36] Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pier  
+387 ric Cistac, Tim Rault, Rémi Louf, Morgan Funtowicz, Joe Davison, Sam Shleifer, Patrick von Platen,   
+388 Clara Ma, Yacine Jernite, Julien Plu, Canwen Xu, Teven Le Scao, Sylvain Gugger, Mariama Drame,   
+389 Quentin Lhoest, and Alexander M. Rush. Transformers: State-of-the-art natural language processing.   
+390 In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System   
+391 Demonstrations, pages 38–45, Online, October 2020. Association for Computational Linguistics.   
+392 [37] Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. GLUE:   
+393 A multi-task benchmark and analysis platform for natural language understanding. In 7th International   
+394 Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenRe  
+395 view.net, 2019.   
+396 [38] Andrew L. Maas, Raymond E. Daly, Peter T. Pham, Dan Huang, Andrew Y. Ng, and Christopher Potts.   
+397 Learning word vectors for sentiment analysis. In Dekang Lin, Yuji Matsumoto, and Rada Mihalcea,   
+398 editors, The 49th Annual Meeting of the Association for Computational Linguistics: Human Language   
+399 Technologies, Proceedings of the Conference, 19-24 June, 2011, Portland, Oregon, USA, pages 142–150.   
+400 The Association for Computer Linguistics, 2011.   
+401 [39] Erik F. Tjong Kim Sang and Fien De Meulder. Introduction to the conll-2003 shared task: Language  
+402 independent named entity recognition. In Walter Daelemans and Miles Osborne, editors, Proceedings   
+403 of the Seventh Conference on Natural Language Learning, CoNLL 2003, Held in cooperation with HLT  
+404 NAACL 2003, Edmonton, Canada, May 31 - June 1, 2003, pages 142–147. ACL, 2003.   
+405 [40] Mitchell P. Marcus, Beatrice Santorini, and Mary Ann Marcinkiewicz. Building a large annotated corpus   
+406 of english: The penn treebank. Comput. Linguistics, 19(2):313–330, 1993.   
+407 [41] Rowan Zellers, Yonatan Bisk, Roy Schwartz, and Yejin Choi. SWAG: A large-scale adversarial dataset   
+408 for grounded commonsense inference. In Ellen Riloff, David Chiang, Julia Hockenmaier, and Jun’ichi   
+409 Tsujii, editors, Proceedings of the 2018 Conference on Empirical Methods in Natural Language Process  
+410 ing, Brussels, Belgium, October 31 - November 4, 2018, pages 93–104. Association for Computational   
+411 Linguistics, 2018.
+
+# 412 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] See Section 4.2.   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] See Section 4.2. (b) Did you include complete proofs of all theoretical results? [No]
+
+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] See supplemental material.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Section 4.2 and appendix.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No]   
+(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] See Section 4.2 and appendix.
+
+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] See Section 5.   
+(b) Did you mention the license of the assets? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No]   
+(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? [No]
+
+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/rdT5GV-LnZU/rdT5GV-LnZU_content_list.json

@@ -0,0 +1,1233 @@
+[
+    {
+        "type": "text",
+        "text": "Not All Attention Is All You Need ",
+        "text_level": 1,
+        "bbox": [
+            294,
+            122,
+            700,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            196,
+            578,
+            252
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            287,
+            535,
+            304
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Beyond the success story of pre-trained language models (PrLMs) in recent natu  \n2 ral language processing, they are susceptible to over-fitting due to unusual large   \n3 model size. To this end, dropout serves as a therapy. However, existing methods   \n4 like random-based, knowledge-based and search-based dropout are more general   \n5 but less effective onto self-attention based models, which are broadly chosen as   \n6 the fundamental architecture of PrLMs. In this paper, we propose a novel dropout   \n7 method named AttendOut to let self-attention empowered PrLMs capable of more   \n8 robust task-specific tuning. We demonstrate that state-of-the-art models with elab  \n9 orate training design may achieve much stronger results. We verify the universal  \n10 ity of our approach on extensive natural language processing tasks. ",
+        "bbox": [
+            150,
+            319,
+            767,
+            459
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "11 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            483,
+            312,
+            501
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "12 Self-attention network (SAN) empowered models like Transformer [1] have achieved remarkable   \n13 success in recent natural language processing, which have been broadly chosen as basic architec  \n14 ture in a series successful pre-trained language models (PrLMs) such as BERT [2], RoBERTa [3],   \n15 ALBERT [4], ELECTRA [5], DeBERTa [6] and GPT [7].   \n16 SAN has drawn a great deal of curiosity on its conceptually simple but powerful attention mecha  \n17 nism. However, SAN still remains a black box and more and more works attempt to unveil its inner   \n18 principle, where the biggest mystery lies in its attention matrix. Our work is inspired by several   \n19 recent discoveries which turn our views up and down. [8, 9] show that fixed Gaussian or even ran  \n20 dom alignment attention matrix may rival standard SAN, while more recently, [10, 11] prove that   \n21 SAN may encounter a rank collapse with deepening of layers. A more concrete explanation is in  \n22 formation diffusion [12], which states that the input vectors are progressively assimilating through   \n23 continuously making self-attention. We attribute these problems to the sever co-adaption [13] be  \n24 tween attention elements, a form of over-fitting onto SAN. As a result, self-attention empowered   \n25 PrLMs hardly bring into their full play, especially for the fine-tuning stage, where task-specific data   \n26 is always with limited capacity.   \n27 Dropout [13] serves as a therapy to deal with the problem, by randomly shutting down a set of units   \n28 during training stage. When specified on self-attention, dropout is equivalent to adding attention   \n29 mask to the attention matrix. However, random-based dropout methods like vanilla Dropout [13] or   \n30 DropConnect [14] are all subject to a pre-defined distribution like Bernoulli or Gaussian, longing for   \n31 exhaustive grid search for an optimal probability. Thereby a variety of works attempt to utilize man  \n32 ual attention mask to obtain a more informative attention matrix [15, 16], whereas all these methods   \n33 require prior knowledge on model or data, which could be costly or unavailable. More recently, the   \n34 rise of Neural Architecture Search [17, 18] gives birth to search-based dropout [19], which automat  \n35 ically chooses an optimal dropout pattern based on additional validation performances. However,   \n36 the huge search space brings heavy consumption and more importantly, the obtained dropout pattern   \n37 is still fixed with a pre-defined probability, which is static and sample-independent, ignoring the   \n38 dynamics within different samples. In this paper, we focus on task-specific tuning of self-attention   \n39 empowered PrLMs and propose a novel dropout method named AttendOut onto attention layers,   \n40 which leverages self-attention to dynamically generate dropout patterns for each attention layer as   \n41 well as each sample through an end-to-end manner. We demonstrate that the previous state-of-the-art   \n42 models with elaborate training design may achieve much stronger results. We verify the universality   \n43 of our approach on extensive natural language processing tasks. Guided by AttendOut, we pro  \n44 pose another two attention regularizers to enable simple but effective performance boost with no   \n45 additional cost. ",
+        "bbox": [
+            148,
+            515,
+            825,
+            570
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            577,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            736,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/bb9e5c7dfb1c536808b7a53013b509ca9c34d20afb292d3c61b86cbda7d324d9.jpg",
+        "image_caption": [
+            "Figure 1: A diagram of different dropout methods, where $p$ refers to the dropout probabilities while $R$ refers to the reward in reinforcement learning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            93,
+            813,
+            243
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            324,
+            825,
+            421
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "46 2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            443,
+            320,
+            459
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "47 Dropout is proposed to alleviate over-fitting problem in DNNs. Apart from vanilla Dropout [13]   \n48 and DropConnect [14] which randomly shut down a subset of activations or hidden weights, there   \n49 are a variety of dropout methods proposed, e.g. Alpha Dropout [20], Variational Dropout [21, 22],   \n50 Adversarial Dropout [23], Energy-based Dropout [24]. However, random-based dropout encounters   \n51 slow experiment cycle due to inevitable grid search. Inspired by Neural Architecture Search [17, 18],   \n52 [19] proposes AutoDropout to automate the process of designing dropout patterns. A similar line of   \n53 work is dynamic tuning of dropout, which further allows adaptive dropout probabilities under differ  \n54 ent training moments. [25] proposes Concrete Dropout with continuous relaxation under Concrete   \n55 distribution, [26] proposes Learnable Bernoulli Dropout under discrete Bernoulli distribution using   \n56 Augment-REINFORCE-Merge estimator [27], while [28] proposes Context Dropout by optimizing   \n57 the evidence lower bound.   \n58 With self-attention network continuously stands out, dropout is being explored onto self-attention   \n59 based models. LayerDrop [29] randomly removes entire SAN blocks, while DropHead [30], Head  \n60 Mask [31] randomly remove certain attention heads. UniDrop [32] unifies these dropout methods,   \n61 which facilitates text classification and machine translation tasks. Additionally, prior knowledge is   \n62 shown highly effective for guiding attention dropout as in SG-Net [15] and SIT [16], which inten  \n63 tionally discard syntax-unrelated attention units with the help of structural clues. ",
+        "bbox": [
+            145,
+            474,
+            825,
+            627
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            632,
+            826,
+            717
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "64 3 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            737,
+            318,
+            753
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "65 In this section, we provide the preliminaries for the proposed approach. We first review the details   \n66 of self-attention proposed in [1]. Based on the specific architecture, we elaborate the concerned   \n67 attention dropout. ",
+        "bbox": [
+            151,
+            770,
+            825,
+            811
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 Self-Attention ",
+        "text_level": 1,
+        "bbox": [
+            160,
+            829,
+            310,
+            844
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "69 Generally, a standard SAN block is mainly composed of an attention layer and several feed-forward   \n70 layers (actually there are residual connection, layer normalization, etc. as well). The input of it is a   \n71 sentence or batch of sentences of length $n$ , which is first embedded through an embedding layer. The   \n72 embedded input $E$ may go through three linear projections $W _ { Q }$ , $W _ { K }$ and $W _ { V }$ referring to query, key   \n73 and value layers respectively, and then obtain three matrices $Q$ , $K$ and $V$ referring to the query, key   \n74 and value components of self-attention. Subsequently, a dot-product of $Q$ and $K$ is taken and then   \n75 normalized using Sof tmax function to obtain the attention matrix $A$ . Then another dot-product of   \n76 $A$ and $V$ follows. The mentioned calculation can be formalized as follow: ",
+        "bbox": [
+            147,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            90,
+            826,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f01579e1ebd392a48f61a52866bee4bea9417a2038606f3c159b6cc6f8fa8f15.jpg",
+        "text": "$$\nA t t e n t i o n ( Q , K , V ) = S o f t m a x \\left( \\frac { Q \\cdot K ^ { T } } { \\sqrt { d _ { k } } } \\right) \\cdot V\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            147,
+            668,
+            183
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where 77 $\\sqrt { d _ { k } }$ is a scaling factor. Finally, the self-attention layer ends up with a linear projection $W _ { O }$ 78 to output. ",
+        "bbox": [
+            143,
+            186,
+            828,
+            217
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "79 During the aforementioned process, we highlight a key phases, that is the attention matrix $A$ , which   \n80 is a dot-product of $n \\times n$ from two separate linear projections $W _ { Q }$ and $W _ { K }$ . $A$ is viewed as a feature   \n81 map which stores the node-to-node significance in different scores. Various works show that there   \n82 hides implicit but highly needed semantic clues. ",
+        "bbox": [
+            147,
+            222,
+            825,
+            279
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 Dropout on Self-Attention ",
+        "text_level": 1,
+        "bbox": [
+            165,
+            292,
+            393,
+            309
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "84 Our dropout will apply to the attention matrix of the concerned attention layer. We first define two   \n85 specific dropouts onto Eq. 1, where both implementations are just as simple as in standard dropout   \n86 via a mask matrix $M$ . ",
+        "bbox": [
+            147,
+            318,
+            825,
+            361
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Weights Dropout. Weights dropout is applied to the attention matrix after Sof tmax function by default, which is formulated as: ",
+        "bbox": [
+            161,
+            375,
+            825,
+            402
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5863a18ac81c302b6bbb246ab4cf03ca69a1f70388758d2c720bc7f29a7e2b9d.jpg",
+        "text": "$$\n{ \\cal A } t t e n t i o n ( Q , K , V ) = \\left( S o f t m a x \\left( { \\frac { Q \\cdot K ^ { T } } { \\sqrt { d _ { k } } } } \\right) \\odot { \\cal M } \\right) \\cdot V\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            405,
+            699,
+            440
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "9 where $M$ is a binary matrix with elements in $\\{ 0 , 1 \\}$ and $\\odot$ refers to element-wise multiplication. ",
+        "bbox": [
+            158,
+            443,
+            803,
+            458
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "90 Scores Dropout. Different from weights dropout, scores dropout is applied before Sof tmax func  \n91 tion, which is formulated as: ",
+        "bbox": [
+            150,
+            470,
+            826,
+            500
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aa41cdf47367563051effa736f464457ab245e254950d8cb98fbd9a23d1e4f17.jpg",
+        "text": "$$\nA t t e n t i o n ( Q , K , V ) = S o f t m a x \\left( \\frac { Q \\cdot K ^ { T } } { \\sqrt { d _ { k } } } + M \\right) \\cdot V\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            502,
+            686,
+            537
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "92 Since the outer Sof tmax, we conduct an addition instead of multiplication, where elements in $M$   \n93 are set to 0 for kept units and $- i n f$ for removed ones. Note that the Sof tmax takes a similar   \n94 function as the scaling factor of $1 / p$ in vanilla Dropout [13], which balances the expectation of the   \n95 network.   \n96 Weights dropout is commonly used in self-attention based models, while scores dropout is less   \n97 explored, which is our focus in this paper. For scores dropout, we need to pay attention to a special   \n98 case, when all attentions are shut down, that is, all elements in $M$ equal to $- i n f$ at the same time.   \n99 Such case can be formulated as follow: ",
+        "bbox": [
+            147,
+            540,
+            825,
+            595
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            602,
+            825,
+            657
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/16385849221d0194e2721e692fbb1d76cf6a080550f5f7518d6976c4bd6cda68.jpg",
+        "text": "$$\nA t t e n t i o n ( Q , K , V ) = S o f t m a x \\left( M \\right) \\cdot V\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            661,
+            643,
+            678
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "100 Note that Sof tmax $( M )$ obtains to a constant matrix, where each unit equals to $1 / n$ . In this case,   \n101 the attention matrix is fixed and consequently the $W _ { Q }$ , $W _ { K }$ and dot-product in between are skipped. ",
+        "bbox": [
+            148,
+            681,
+            826,
+            710
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "102 4 Methodology ",
+        "text_level": 1,
+        "bbox": [
+            145,
+            728,
+            313,
+            744
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "103 In this paper, we propose Attention differentiable dropOut (AttendOut), which contributes technique   \n104 novelty in the following way: (1) dynamic and task-specific tuned; (2) end-to-end trained; (3) gra  \n105 dient optimized dropout method onto self-attention empowered PrLMs. We elaborate our approach   \n106 with two parts, in which the first is composition, while the second is training algorithm. ",
+        "bbox": [
+            147,
+            758,
+            825,
+            815
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.1 Elements of AttendOut ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            830,
+            374,
+            844
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "108 Our training architecture is composed of three modules, A-Net (Attacker), D-Net (Defender) and   \n109 G-Net (Generator). D-Net and A-Net are two identical models and trained simultaneously through   \n110 standard gradient descent, while G-Net is a learnable dropout maker and trained through policy   \n111 gradient. Now we elaborate each of them.   \n112 Defender - Attacker As suggested, defender and attacker are two competitors playing a game   \n113 with each other on specific criteria, e.g. training accuracy, training loss. Specifically, D-Net and A  \n114 Net are two identical self-attention empowered PrLMs, e.g. BERT, RoBERTa. However, they follow   \n115 different dropout strategies. D-Net receives regular dropout as default in specific models, while A  \n116 Net receives additional dropout decision from G-Net onto its corresponding attention layers.   \n117 Generator G-Net acts as a dropout maker through generating a mask matrix for each attention   \n118 layer during training stage. As aforementioned, the common dropout strategies rely on randomness,   \n119 which intends to shut down the co-adaption but not powerful enough. However, our dropout maker   \n120 is an agent which is able to intelligently choose and learn dropout patterns for each sample. Specif  \n121 ically, after training for a fixed number of steps, we conduct evaluation for both A-Net and D-Net.   \n122 When A-Net obtains a higher score than D-Net, which means attacker wins the game, G-Net will be   \n123 rewarded positively. When defender wins, G-Net will be punished with a negative reward. In con  \n124 sequence, G-Net learns appropriate dropout patterns through the game between D-Net and A-Net,   \n125 while assisting A-Net to win the game. On the other hand, A-Net needs to be stronger when training   \n126 under such powerful dropout, which makes it much more robust from over-fitting. Compared to   \n127 search-based dropout, G-Net is triggered by the difference between two model derivatives with and   \n128 without dropout, instead of the final feedback on validation set, which makes it end-to-end-possible   \n129 and sample-dependent.   \n130 The design of G-Net is the most delicate part, which is also a self-attention based model with iden  \n131 tical number of layers with D-Net and A-Net. However, we make several improvements. 1) G-Net   \n132 only exports the attention scores from attention layers with no extra output layers, from which we   \n133 apply Gumbel [33, 34] to sample the actions to obtain the dropout mask. 2) G-Net only makes   \n134 one-head attention and share one group of parameters for all attention layers. 3) G-Net is excluded   \n135 of feed-forward layers, which may obscure the impact of self-attention [11, 10]. ",
+        "bbox": [
+            142,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            90,
+            826,
+            161
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            178,
+            826,
+            358
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            363,
+            825,
+            448
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 Training with AttendOut ",
+        "text_level": 1,
+        "bbox": [
+            165,
+            465,
+            387,
+            481
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "37 The core of training with AttendOut is to find a way to optimize G-Net, which receives signals from   \n38 the difference between D-Net and A-Net. Supposing there is a list of dropout actions by G-Net: ",
+        "bbox": [
+            153,
+            492,
+            825,
+            521
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f56aa511a90840709dd115b79e6fc5074ed41c19a9a388f0fef2fc76470b0bc3.jpg",
+        "text": "$$\na _ { 1 : T } = \\{ a _ { 1 } , a _ { 2 } , a _ { 3 } , \\cdot \\cdot \\cdot , a _ { T } \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            542,
+            594,
+            560
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "139 where $T$ refers to the number of samples, for each action $a _ { t }$ , G-Net may achieve a reward $r _ { t }$ . The   \n140 optimization objective is to maximize the overall rewards of list $a _ { 1 : T }$ , denoted as $R$ , that is: ",
+        "bbox": [
+            137,
+            565,
+            826,
+            594
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1f925c0b893f3ababfc4e48a4dfc58660bc8949245ed33cd5b19a8d1445be379.jpg",
+        "text": "$$\nJ ( \\theta _ { G } ) = E _ { P ( a _ { 1 : T } ; \\theta _ { G } ) } [ R ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            616,
+            581,
+            633
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where 141 $\\begin{array} { r } { R = \\sum _ { t = 1 } ^ { T } r _ { t } } \\end{array}$ . Since $R$ is non-differentiable, we use policy gradient to update $\\theta _ { G }$ ",
+        "bbox": [
+            135,
+            642,
+            820,
+            659
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fc3fb3755389ff8cd6bbf7ca9fba13cdc120ecc31a6e7d843bc1a26190ce9f1c.jpg",
+        "text": "$$\n\\nabla _ { \\theta _ { G } } J ( \\theta _ { G } ) = \\sum _ { t = 1 } ^ { T } E _ { P ( a _ { 1 : T } ; \\theta _ { G } ) } [ \\nabla _ { \\theta _ { G } } \\log P ( a _ { t } | a _ { ( t - 1 ) : 1 } ; \\theta _ { G } ) r _ { t } ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            676,
+            699,
+            719
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "142 The above equation could be approximated as: ",
+        "bbox": [
+            142,
+            724,
+            480,
+            739
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf59206867b48bb4f3a19df513829ce8bbf5245603bb217e38172ed1cb642f13.jpg",
+        "text": "$$\n\\frac { 1 } { m } \\sum _ { k = 1 } ^ { m } \\sum _ { t = 1 } ^ { T } \\nabla _ { \\theta _ { G } } \\log P ( a _ { t } | a _ { ( t - 1 ) : 1 } ; \\theta _ { G } ) r _ { t }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            758,
+            633,
+            803
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "143 For a model with $n$ attention layers, each dropout decision is composed of $n$ inner decisions of each   \n144 layer. Additionally, each attention layer contains an attention matrix of $l \\times l$ , namely $l ^ { 2 }$ elements   \n145 dropped or kept. Thus, we denote a dropout unit as $d ^ { i j }$ , where $i$ refers to the $i ^ { t h }$ layer while $j$ refers   \n146 to the $j ^ { t h }$ element of the attention matrix.   \n147 However, $n l ^ { 2 }$ dropout units bring a huge space, which makes it impossible to calculate the joint prob  \n148 ability. To this end, we introduce the independence assumption that each dropout unit is independent   \n149 with each other. Under the relaxation, we can make the following probability likelihood: ",
+        "bbox": [
+            142,
+            806,
+            825,
+            863
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            868,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/346785ebf584a4d35ea439aa48cc1640667b81c2749d4132d4ecb7a8ccf6cef8.jpg",
+        "text": "$$\n\\log P ( a _ { t } | a _ { ( t - 1 ) : 1 } ; \\theta _ { G } ) = \\frac { 1 } { n l ^ { 2 } } \\sum _ { i , j } \\log P ( d _ { t } ^ { i j } | d _ { ( t - 1 ) : 1 } ^ { i j } ; \\theta _ { G } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            108,
+            686,
+            148
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the summation 150 $\\textstyle \\sum _ { i = 1 } ^ { n } \\sum _ { j = 1 } ^ { l ^ { 2 } }$ is briefly denoted as $\\textstyle \\sum _ { i , j }$ ",
+        "bbox": [
+            140,
+            160,
+            576,
+            181
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "151 Thus, the final gradient could be formalized as: ",
+        "bbox": [
+            142,
+            185,
+            485,
+            202
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/49ce366e69ce1d5407a56a9f7f4fb0540be68e548bc04e368cb1f74925ed54de.jpg",
+        "text": "$$\n\\nabla _ { \\theta _ { G } } J ( \\theta _ { G } ) = \\frac { 1 } { m } \\frac { 1 } { n l ^ { 2 } } \\sum _ { k = 1 } ^ { m } \\sum _ { t = 1 } ^ { T } \\sum _ { i , j } \\nabla _ { \\theta _ { G } } \\log P ( d _ { t } ^ { i j } | d _ { ( t - 1 ) : 1 } ^ { i j } ; \\theta _ { G } ) ( r _ { t } - b )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            212,
+            728,
+            258
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "152 where $b$ is a baseline function of moving average [35]. Note that we do not apply additional regular  \n153 izers like L0 and L1 penalty, which impose unnecessary bias.   \n154 Algorithm 1 summarizes the overall procedure of training PrLMs with AttendOut. We first initialize   \n155 all three networks. Note that D-Net and A-Net should be kept identical at the beginning of each   \n156 training step. A straightforward strategy is to choose the better one to cover the other. To add   \n157 randomness, we sample from D-Net and A-Net based on their evaluation performances, with higher   \n158 probability for the better one. Then for each step, D-Net and A-Net are fed with the same mini-batch   \n159 data and updated via standard gradient descent, meanwhile each batch will be cached. After training   \n160 for $T$ steps, which we denote as a dropout step, both D-Net and A-Net are evaluated on additional   \n161 validation samples, which could be development set data, noisy training data or a small split of train  \n162 ing data. In this paper, we simply use development set. For efficiency, we make random sampling   \n163 on it to retrieve $T$ samples for evaluation. Based on the evaluation scores, G-Net is rewarded with   \n164 $\\{ r _ { 1 } , r _ { 2 } , r _ { 3 } , \\cdot \\cdot \\cdot , r _ { T } \\}$ and updated via Eq. 5. At the end of each dropout step, the cached samples   \n165 will be released and D-Net and A-Net will be re-initialized. ",
+        "bbox": [
+            142,
+            268,
+            826,
+            299
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            304,
+            826,
+            469
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            585,
+            160,
+            594
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 AttendOut ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            497,
+            333,
+            511
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Input: Attacker $A$ , Defender $D$ , Generator $G$ , dropout   \nstep $T$   \n1: initialize $\\theta _ { D }$ , $\\theta _ { A }$ , $\\theta _ { G }$ , where $\\theta _ { D } = \\theta _ { A }$   \n2: for each training step do   \n3: $\\theta _ { D }  \\theta _ { D } ^ { \\prime }$   \n4: dropout $A$ with $G$ via Eq. 3   \n5: $\\theta _ { A }  \\theta _ { A } ^ { \\prime }$   \n6: for each $T$ steps do   \n7: evaluate $D$ and $A$ and reward $G$   \n8: $\\theta _ { G }  \\theta _ { G } ^ { \\prime }$ via Eq. 5   \n9: initialize $\\theta _ { D }$ , $\\theta _ { A }$ for next step   \n10: end for   \n11: end for   \n167 Resource Usage We notice that training PrLMs with AttendOut may sacrifice time and memory   \n168 cost. The detailed resource usage is shown in Appendix. Taking RoBERTa as an example, the   \n169 algorithm requires two RoBERTa models as well as a smaller self-attention based generator, which   \n170 is $\\mathrm { { \\bar { 1 } / 3 } }$ of RoBERTa size. Considering cached samples, roughly speaking, AttendOut requires twice   \n171 graphic memory as well as twice training time compared to a single model, which is a middle speed   \n172 line between random-based dropout and neural architecture search (Dropout [13] $<$ AttendOut $\\ll$   \n173 AutoDropout [19]). However, AttendOut contributes to remarkable performance gain compared to   \n174 other attention dropout methods.   \n175 Pre-training Our approach is both feasible for both fine-tuning and pre-training stage of PrLMs   \n176 but expensive for the latter. However, we try to serve for the most delicate part of concerned issue,   \n177 since pre-training is generally done on large-scale data with modest training epochs, which makes it   \n178 less susceptible from over-fitting. ",
+        "bbox": [
+            173,
+            513,
+            532,
+            696
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/fd257beb2fcc68132803a55e565d83d523ed0eecbb7ad908e1916676d82e7134.jpg",
+        "image_caption": [
+            "Figure 2: Architecture of G-Net. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            553,
+            489,
+            807,
+            676
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            723,
+            825,
+            834
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/3c7ad4603ab51b6e1e546706fb10ce9ec0af7be9d7388369f8daa520017381ba.jpg",
+        "table_caption": [
+            "Table 1: Results (test / dev) of GLUE sub-tasks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>SST-2 Acc</td><td>MRPC F1</td><td>QNLI Acc</td><td>MNLI-mm Acc</td><td>CoLA Mcc</td></tr><tr><td>BERT</td><td>92.9 / 92.2</td><td>86.6 / 86.3</td><td>89.7 /88.9</td><td>83.3 /84.0</td><td>51.2 / 58.8</td></tr><tr><td>+ AtendOut</td><td>93.6 / 93.8</td><td>88.1 / 87.5</td><td>90.2 / 91.1</td><td>84.2 /84.6</td><td>57.4 / 60.9</td></tr><tr><td>RoBERTa</td><td>95.4 / 94.4</td><td>90.5 /90.2</td><td>92.9 /92.0</td><td>86.1 /86.6</td><td>61.3 / 62.5</td></tr><tr><td>+ AtendOut</td><td>96.2 / 95.1</td><td>91.2 / 90.9</td><td>93.3 /93.0</td><td>87.3 /87.8</td><td>63.0 / 63.8</td></tr></table>",
+        "bbox": [
+            223,
+            108,
+            771,
+            217
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/ab865c827d0558b20f9b92fd2f5e57a47106da959ea716a92172e054389c1020.jpg",
+        "table_caption": [
+            "Table 2: Results of IMDB, CoNLL03, PTB and SWAG respectively. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>IMDB Acc</td><td>CoNLL03 F1</td><td>PTB F1</td><td>SWAG Acc</td></tr><tr><td>BERT</td><td>92.2</td><td>94.1</td><td>95.4</td><td>81.1</td></tr><tr><td>+ AttendOut</td><td>92.9</td><td>94.7</td><td>96.5</td><td>81.6</td></tr><tr><td>RoBERTa</td><td>93.6</td><td>94.5</td><td>96.6</td><td>83.8</td></tr><tr><td>+ AttendOut</td><td>94.2</td><td>95.2</td><td>97.3</td><td>84.1</td></tr></table>",
+        "bbox": [
+            303,
+            262,
+            689,
+            369
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "179 5 Experimental Setup ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            404,
+            372,
+            421
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "180 We demonstrate the universal effectiveness of AttendOut on extensive natural language processing   \n181 tasks. For all mentioned tasks, we apply our method on BERT [2] and its stronger variant RoBERTa   \n182 [3]. Our implementations are based on PyTorch using transformers [36]. For further training details,   \n183 please refer to Appendix.   \n184 Our experiments include: (1) natural language understanding: General Language Understanding   \n185 Evaluation (GLUE) benchmark [37], a collection of nine natural language understanding tasks (here   \n186 we experiment on five of them, SST-2, MRPC, QNLI, MNLI-mm and CoLA; (2) document clas  \n187 sification: IMDB [38], a sentiment analysis dataset where about $15 \\%$ of the documents are longer   \n188 than 512 word-pieces; (3) named entity recognition: CoNLL2003 [39]; (4) part-of-speech tag  \n189 ging: English Penn Treebank (PTB) [40]; (5) multiple choices question answering: SWAG [41].   \n190 We report both test and development results for GLUE sub-tasks since the large bias between them,   \n191 while development results only for all the other tasks.   \n192 Note that we only adjust the dropout steps and keep all other parameters the same for strict fair   \n193 comparison. For example, the parameters we use in RoBERTa are identical with what we use in   \n194 training with AttendOut including both D-Net and A-Net. ",
+        "bbox": [
+            142,
+            443,
+            825,
+            498
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            505,
+            826,
+            616
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            622,
+            825,
+            664
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 Results ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            696,
+            266,
+            713
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.1 Significance Analysis ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            734,
+            357,
+            750
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "97 Pictorially in Table 1, RoBERTa is strong enough as it outperforms BERT by a big margin, while   \n98 AttendOut empowered RoBERTa still outperforms it on all five GLUE sub-tasks. For small-scale   \n99 datasets, which are more likely to over-fit, AttendOut helps unfold remarkable performance gain   \n00 $( 1 2 . 1 \\% \\ / \\ 3 . 5 \\%$ over BERT on CoLA, $1 . 7 \\% / 1 . 4 \\%$ over BERT on MRPC). However, for large  \n01 scale one like MNLI, which tends to be more stable, AttendOut still produces considerable boost,   \n02 $( 1 . 4 \\% / 1 . 4 \\%$ over RoBERTa, $1 . 1 \\% / 0 . 7 \\%$ over BERT).   \n203 Furthermore, AttendOut is shown universally effective as in Table 2. For POS Tagging, BERT   \n204 and RoBERTa have achieved very strong baselines, while AttendOut empowered ones are even   \n205 stronger, $3 . 1 \\%$ over BERT on PTB). Similar results are seen on document classification and NER.   \n206 For SWAG, however, AttendOut seems weakly effective $\\mathbf { 0 . 6 \\% }$ over BERT, $0 . 4 \\%$ over RoBERTa). ",
+        "bbox": [
+            151,
+            766,
+            825,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/5fb2129c880eb1d2bbb3f4e477445ad7dac156a1c0699af1632c637d63bc4d20.jpg",
+        "image_caption": [
+            "Figure 3: Dropout probabilities on specific attention layers over training steps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            107,
+            794,
+            238
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3195061f460620f90c7af6ac43fe036d69fcbd8c0b3dc54487b440d5ed05c143.jpg",
+        "image_caption": [
+            "Figure 4: Convergence over training epochs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            296,
+            794,
+            428
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "207 6.2 Visual Analysis ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            481,
+            320,
+            496
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Dropout Patterns Another concerned issue is the dropout proportions by AttendOut. Figure 3 depicts the patterns on several datasets. We may find several interesting phenomenons. First, the overall patterns largely differ from datasets, which is fair since AttendOut is sample-dependent. However, we may observe something in common. Overall, the lower layers take higher dropout probabilities. For example on QNLI, the first layer almost remains steady with the probability of 0.55 during the training process, while the fourth one continuously decays in a higher rate. Intuitively, the first three layers undertake a similar trend in each dataset, while there might be an up and down for the fourth one as in SST-2 and CoLA. Especially for CoLA, we see unusual high dropout probabilities in the final period (around 0.9), which are close to complete dropout. We notice that CoLA is a small set with 8500 training samples, on which SAN model is more inclined to suffer from over-fitting. Therefore, PrLM on CoLA encounters more intensive dropout through AttendOut. ",
+        "bbox": [
+            173,
+            507,
+            825,
+            659
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "219 Convergence Figure 4 depicts the accuracy trends of RoBERTa on SST-2, QNLI, MNLI respec  \n220 tively. Due to a stronger dropout module, the one with AttendOut tends to fall behind (SST-2,   \n221 MNLI) at the beginning of training. However, model becomes stronger since the second epoch   \n222 (SST-2, QNLI). Especially on MNLI, RoBERTa obtains better results in the first two epochs and it   \n223 drops in the last one, while with AttendOut, the performance is steadily rising for all three epochs. ",
+        "bbox": [
+            143,
+            675,
+            825,
+            744
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7 Ablation Study ",
+        "text_level": 1,
+        "bbox": [
+            168,
+            765,
+            330,
+            782
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we conduct further experiments to demonstrate the effectiveness of AttendOut. Due to space limitation, we conduct corresponding experiments on development sets only. ",
+        "bbox": [
+            176,
+            797,
+            825,
+            825
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7.1 Attention Dropout ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            843,
+            341,
+            858
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Vanilla Dropout We conduct comparison with vanilla Dropout [13], in which we dropout the attention matrix for all layers with Bernoulli distribution of $p$ . Here, we choose the dropout probabilities in {0.1, 0.2}. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/6992bb522a8d26ca2161c8c42613732b72cc254464fbf4209a729a603f4f23db.jpg",
+        "table_caption": [
+            "Table 3: Comparison of AttendOut, vanilla Dropout and LayerDrop. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>CoLA</td><td>QNLI</td><td>MNLI-mm</td></tr><tr><td>RoBERTa</td><td>62.5</td><td>92.0</td><td>86.6</td></tr><tr><td>+ Vanilla</td><td>61.3</td><td>92.2</td><td>86.9</td></tr><tr><td>+ AttendOut</td><td>63.8</td><td>93.1</td><td>87.8</td></tr><tr><td>+ LayerDrop</td><td>62.1</td><td>92.6</td><td>87.1</td></tr><tr><td>+ Attn.LayerDrop</td><td>64.2</td><td>92.7</td><td>87.3</td></tr></table>",
+        "bbox": [
+            312,
+            109,
+            681,
+            217
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/ec9b7719a518050ab731af2292ba4eec7a42f59ef3043fcbf94b28b4458c16b3.jpg",
+        "table_caption": [
+            "Table 4: Comparison of AttendOut and scheduled Bernoulli dropout. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>CoLA</td><td>QNLI</td><td>SWAG</td></tr><tr><td>RoBERTa</td><td>62.5</td><td>92.0</td><td>83.8</td></tr><tr><td>+ Scheduler</td><td>63.3</td><td>92.6</td><td>83.6</td></tr><tr><td>+ AttendOut</td><td>63.8</td><td>93.1</td><td>84.1</td></tr></table>",
+        "bbox": [
+            343,
+            261,
+            650,
+            334
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "231 LayerDrop We also compare with LayerDrop [29], which focuses on skipping the entire encoder   \n232 blocks, Inspired of it, we design another strategy which randomly skips attention layers via Eq. 4.   \n233 For fair enough comparison, we set the dropout probabilities to 0.2 for both methods, following the   \n234 settings in [29].   \n235 Intuitively in Table 3, vanilla Dropout with fixed probability does not produce noticeable gain $( 1 . 9 \\%$   \n236 bellow RoBERTa on CoLA). However, AttendOut shows powerful advantage $4 . 1 \\%$ , $1 . 0 \\%$ and $1 . 0 \\%$   \n237 over vanilla Dropout on CoLA, QNLI and MNLI), which stresses the necessity of dynamic dropout   \n238 patterns rather than fixed static one. On the other hand, both layer-level regularizers are effective,   \n239 while attention LayerDrop performs stronger and more stable on all the three. Especially on CoLA,   \n240 it outperforms RoBERTa by 1.7 points, while LayerDrop meets a performance drop, which demon  \n241 strates that removing the attention layers act as a more effective regularizer than removing the entire   \n242 SAN block as for self-attention based models. ",
+        "bbox": [
+            140,
+            369,
+            826,
+            425
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            431,
+            825,
+            541
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "243 7.2 Pattern Approximation ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            569,
+            375,
+            585
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "244 Guided by AttendOut, we design a dropout scheduler, in which we utilize piece-wise linearity to   \n245 approximate the real curves as depicted in Figure 3. Taking QNLI as an example, we initialize   \n246 the dropout probabilities to 0.6 for all attention layers and set a a specific slope for each of them.   \n247 Note that here the corresponding mask matrices are randomly-generated and subject to Bernoulli   \n248 distribution. In AttendOut, however, the distribution are learned dynamically through self-attention   \n249 of G-Net.   \n250 As shown in Table 4, RoBERTa with scheduled Bernoulli dropout works surprisingly well on both   \n251 CoLA and QNLI, which outperforms RoBERTa by 0.8 and 0.6 points respectively, closer to At  \n252 tendOut, even if the strategy here is random-based and much looser. The guided scheduled dropout   \n253 helps unfold the correctness of the dynamic dropout patterns learned by AttendOut as well as the   \n254 self-attention based dropout maker. ",
+        "bbox": [
+            140,
+            599,
+            825,
+            683
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            689,
+            825,
+            758
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "255 8 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            790,
+            299,
+            806
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This paper focuses on the co-adaption problem of deep self-attention networks, and presents a novel dropout method onto self-attention empowered pre-trained language models. Extensive experiments on multiple natural language processing tasks demonstrate that our proposed approach is universal and qualified to enable more robust task-specific tuning, which contributes to much stronger stateof-the-arts. We probe into the learned dropout patterns on different tasks, which empirically guide us to the very needed dynamic attention dropout design. ",
+        "bbox": [
+            169,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "262 References   \n263 [1] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz   \n264 Kaiser, and Illia Polosukhin. Attention is all you need. In Isabelle Guyon, Ulrike von Luxburg, Samy   \n265 Bengio, Hanna M. Wallach, Rob Fergus, S. V. N. Vishwanathan, and Roman Garnett, editors, Advances   \n266 in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing   \n267 Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 5998–6008, 2017.   \n268 [2] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: pre-training of deep bidi  \n269 rectional transformers for language understanding. In Jill Burstein, Christy Doran, and Thamar Solorio,   \n270 editors, Proceedings of the 2019 Conference of the North American Chapter of the Association for Com  \n271 putational Linguistics: Human Language Technologies, NAACL-HLT 2019, Minneapolis, MN, USA, June   \n272 2-7, 2019, Volume 1 (Long and Short Papers), pages 4171–4186. Association for Computational Linguis  \n273 tics, 2019.   \n274 [3] Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis,   \n275 Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized BERT pretraining approach.   \n276 CoRR, abs/1907.11692, 2019.   \n277 [4] Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, and Radu Soricut.   \n278 ALBERT: A lite BERT for self-supervised learning of language representations. In 8th International   \n279 Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. Open  \n280 Review.net, 2020.   \n281 [5] Kevin Clark, Minh-Thang Luong, Quoc V. Le, and Christopher D. Manning. ELECTRA: pre-training   \n282 text encoders as discriminators rather than generators. In 8th International Conference on Learning Rep  \n283 resentations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   \n284 [6] Pengcheng He, Xiaodong Liu, Jianfeng Gao, and Weizhu Chen. {DEBERTA}: {DECODING}-   \n285 {enhanced} {bert} {with} {disentangled} {attention}. In International Conference on Learning Repre  \n286 sentations, 2021.   \n287 [7] Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding   \n288 by generative pre-training. 2018.   \n289 [8] Weiqiu You, Simeng Sun, and Mohit Iyyer. Hard-coded gaussian attention for neural machine translation.   \n290 In Dan Jurafsky, Joyce Chai, Natalie Schluter, and Joel R. Tetreault, editors, Proceedings of the 58th   \n291 Annual Meeting of the Association for Computational Linguistics, ACL 2020, Online, July 5-10, 2020,   \n292 pages 7689–7700. Association for Computational Linguistics, 2020.   \n293 [9] Yi Tay, Dara Bahri, Donald Metzler, Da-Cheng Juan, Zhe Zhao, and Che Zheng. Synthesizer: Rethinking   \n294 self-attention in transformer models. CoRR, abs/2005.00743, 2020.   \n295 [10] Sinong Wang, Belinda Z. Li, Madian Khabsa, Han Fang, and Hao Ma. Linformer: Self-attention with   \n296 linear complexity. CoRR, abs/2006.04768, 2020.   \n297 [11] Yihe Dong, Jean-Baptiste Cordonnier, and Andreas Loukas. Attention is not all you need: Pure attention   \n298 loses rank doubly exponentially with depth. CoRR, abs/2103.03404, 2021.   \n299 [12] Saurabh Goyal, Anamitra Roy Choudhury, Saurabh Raje, Venkatesan T. Chakaravarthy, Yogish Sabhar  \n300 wal, and Ashish Verma. Power-bert: Accelerating BERT inference via progressive word-vector elimi  \n301 nation. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18   \n302 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 3690–3699.   \n303 PMLR, 2020.   \n304 [13] Nitish Srivastava, Geoffrey E. Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov.   \n305 Dropout: a simple way to prevent neural networks from overfitting. J. Mach. Learn. Res., 15(1):1929–   \n306 1958, 2014.   \n307 [14] Li Wan, Matthew D. Zeiler, Sixin Zhang, Yann LeCun, and Rob Fergus. Regularization of neural networks   \n308 using dropconnect. In Proceedings of the 30th International Conference on Machine Learning, ICML   \n309 2013, Atlanta, GA, USA, 16-21 June 2013, volume 28 of JMLR Workshop and Conference Proceedings,   \n310 pages 1058–1066. JMLR.org, 2013.   \n311 [15] Zhuosheng Zhang, Yuwei Wu, Junru Zhou, Sufeng Duan, Hai Zhao, and Rui Wang. Sg-net: Syntax  \n312 guided machine reading comprehension. In The Thirty-Fourth AAAI Conference on Artificial Intelligence,   \n313 AAAI 2020, The Thirty-Second Innovative Applications of Artificial Intelligence Conference, IAAI 2020,   \n314 The Tenth AAAI Symposium on Educational Advances in Artificial Intelligence, EAAI 2020, New York, NY,   \n315 USA, February 7-12, 2020, pages 9636–9643. AAAI Press, 2020. ",
+        "bbox": [
+            140,
+            82,
+            828,
+            933
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "[16] Hongqiu Wu, Hai Zhao, and Min Zhang. Code summarization with structure-induced transformer. arXiv preprint arXiv:2012.14710, 2020.   \n[17] Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017.   \n[18] Hanxiao Liu, Karen Simonyan, and Yiming Yang. DARTS: differentiable architecture search. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.   \n[19] Hieu Pham and Quoc V. Le. Autodropout: Learning dropout patterns to regularize deep networks. CoRR, abs/2101.01761, 2021.   \n[20] Günter Klambauer, Thomas Unterthiner, Andreas Mayr, and Sepp Hochreiter. Self-normalizing neural networks. In Isabelle Guyon, Ulrike von Luxburg, Samy Bengio, Hanna M. Wallach, Rob Fergus, S. V. N. Vishwanathan, and Roman Garnett, editors, Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 971–980, 2017.   \n[21] Avrim Blum, Nika Haghtalab, and Ariel D. Procaccia. Variational dropout and the local reparameterization trick. In Corinna Cortes, Neil D. Lawrence, Daniel D. Lee, Masashi Sugiyama, and Roman Garnett, editors, Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pages 2575–2583, 2015.   \n[22] Dmitry Molchanov, Arsenii Ashukha, and Dmitry P. Vetrov. Variational dropout sparsifies deep neural networks. In Doina Precup and Yee Whye Teh, editors, Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, volume 70 of Proceedings of Machine Learning Research, pages 2498–2507. PMLR, 2017.   \n[23] Sungrae Park, Jun-Keon Park, Su-Jin Shin, and Il-Chul Moon. Adversarial dropout for supervised and semi-supervised learning. In Sheila A. McIlraith and Kilian Q. Weinberger, editors, Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence, (AAAI-18), the 30th innovative Applications of Artificial Intelligence (IAAI-18), and the 8th AAAI Symposium on Educational Advances in Artificial Intelligence (EAAI-18), New Orleans, Louisiana, USA, February 2-7, 2018, pages 3917–3924. AAAI Press, 2018.   \n[24] Hojjat Salehinejad and Shahrokh Valaee. Edropout: Energy-based dropout and pruning of deep neural networks. CoRR, abs/2006.04270, 2020.   \n[25] Yarin Gal, Jiri Hron, and Alex Kendall. Concrete dropout. In Isabelle Guyon, Ulrike von Luxburg, Samy Bengio, Hanna M. Wallach, Rob Fergus, S. V. N. Vishwanathan, and Roman Garnett, editors, Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 3581–3590, 2017.   \n[26] Shahin Boluki, Randy Ardywibowo, Siamak Zamani Dadaneh, Mingyuan Zhou, and Xiaoning Qian. Learnable bernoulli dropout for bayesian deep learning. In Silvia Chiappa and Roberto Calandra, editors, The 23rd International Conference on Artificial Intelligence and Statistics, AISTATS 2020, 26-28 August 2020, Online [Palermo, Sicily, Italy], volume 108 of Proceedings of Machine Learning Research, pages 3905–3916. PMLR, 2020.   \n[27] Mingzhang Yin and Mingyuan Zhou. ARM: augment-reinforce-merge gradient for stochastic binary networks. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.   \n[28] Xinjie Fan, Shujian Zhang, Korawat Tanwisuth, Xiaoning Qian, and Mingyuan Zhou. Contextual dropout: An efficient sample-dependent dropout module. CoRR, abs/2103.04181, 2021.   \n[29] Angela Fan, Edouard Grave, and Armand Joulin. Reducing transformer depth on demand with structured dropout. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020.   \n[30] Wangchunshu Zhou, Tao Ge, Furu Wei, Ming Zhou, and Ke Xu. Scheduled drophead: A regularization method for transformer models. In Trevor Cohn, Yulan He, and Yang Liu, editors, Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: Findings, EMNLP 2020, Online Event, 16-20 November 2020, pages 1971–1980. Association for Computational Linguistics, 2020. ",
+        "bbox": [
+            147,
+            92,
+            828,
+            917
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "369 [31] Zewei Sun, Shujian Huang, Xinyu Dai, and Jiajun Chen. Alleviating the inequality of attention heads for   \n370 neural machine translation. CoRR, abs/2009.09672, 2020.   \n371 [32] Zhen Wu, Lijun Wu, Meng Qi, Yingce Xia, Shufang Xie, Tao Qin, Xinyu Dai, and Tie-Yan Liu. Unidrop:   \n372 A simple yet effective technique to improve transformer without extra cost. In Proceedings of the The 2021   \n373 Conference of the North American Chapter of the Association for Computational Linguistics - Human   \n374 Language Technologies, Volume 1 (Long Papers), 2021.   \n375 [33] Chris J. Maddison, Daniel Tarlow, and Tom Minka. $\\mathbf { A } ^ { * }$ sampling. In Zoubin Ghahramani, Max Welling,   \n376 Corinna Cortes, Neil D. Lawrence, and Kilian Q. Weinberger, editors, Advances in Neural Information   \n377 Processing Systems 27: Annual Conference on Neural Information Processing Systems 2014, December   \n378 8-13 2014, Montreal, Quebec, Canada, pages 3086–3094, 2014.   \n379 [34] Xinwei Geng, Longyue Wang, Xing Wang, Bing Qin, Ting Liu, and Zhaopeng Tu. How does selective   \n380 mechanism improve self-attention networks? In Dan Jurafsky, Joyce Chai, Natalie Schluter, and Joel R.   \n381 Tetreault, editors, Proceedings of the 58th Annual Meeting of the Association for Computational Linguis  \n382 tics, ACL 2020, Online, July 5-10, 2020, pages 2986–2995. Association for Computational Linguistics,   \n383 2020.   \n384 [35] Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement   \n385 learning. Mach. Learn., 8:229–256, 1992.   \n386 [36] Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pier  \n387 ric Cistac, Tim Rault, Rémi Louf, Morgan Funtowicz, Joe Davison, Sam Shleifer, Patrick von Platen,   \n388 Clara Ma, Yacine Jernite, Julien Plu, Canwen Xu, Teven Le Scao, Sylvain Gugger, Mariama Drame,   \n389 Quentin Lhoest, and Alexander M. Rush. Transformers: State-of-the-art natural language processing.   \n390 In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System   \n391 Demonstrations, pages 38–45, Online, October 2020. Association for Computational Linguistics.   \n392 [37] Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. GLUE:   \n393 A multi-task benchmark and analysis platform for natural language understanding. In 7th International   \n394 Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenRe  \n395 view.net, 2019.   \n396 [38] Andrew L. Maas, Raymond E. Daly, Peter T. Pham, Dan Huang, Andrew Y. Ng, and Christopher Potts.   \n397 Learning word vectors for sentiment analysis. In Dekang Lin, Yuji Matsumoto, and Rada Mihalcea,   \n398 editors, The 49th Annual Meeting of the Association for Computational Linguistics: Human Language   \n399 Technologies, Proceedings of the Conference, 19-24 June, 2011, Portland, Oregon, USA, pages 142–150.   \n400 The Association for Computer Linguistics, 2011.   \n401 [39] Erik F. Tjong Kim Sang and Fien De Meulder. Introduction to the conll-2003 shared task: Language  \n402 independent named entity recognition. In Walter Daelemans and Miles Osborne, editors, Proceedings   \n403 of the Seventh Conference on Natural Language Learning, CoNLL 2003, Held in cooperation with HLT  \n404 NAACL 2003, Edmonton, Canada, May 31 - June 1, 2003, pages 142–147. ACL, 2003.   \n405 [40] Mitchell P. Marcus, Beatrice Santorini, and Mary Ann Marcinkiewicz. Building a large annotated corpus   \n406 of english: The penn treebank. Comput. Linguistics, 19(2):313–330, 1993.   \n407 [41] Rowan Zellers, Yonatan Bisk, Roy Schwartz, and Yejin Choi. SWAG: A large-scale adversarial dataset   \n408 for grounded commonsense inference. In Ellen Riloff, David Chiang, Julia Hockenmaier, and Jun’ichi   \n409 Tsujii, editors, Proceedings of the 2018 Conference on Empirical Methods in Natural Language Process  \n410 ing, Brussels, Belgium, October 31 - November 4, 2018, pages 93–104. Association for Computational   \n411 Linguistics, 2018. ",
+        "bbox": [
+            148,
+            93,
+            825,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            108,
+            826,
+            746
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "412 Checklist ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            766,
+            254,
+            781
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            791,
+            330,
+            804
+        ],
+        "page_idx": 10
+    },
+    {
+        "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 4.2.   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            240,
+            809,
+            826,
+            893
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            215,
+            898,
+            467,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] See Section 4.2. (b) Did you include complete proofs of all theoretical results? [No] ",
+        "bbox": [
+            235,
+            92,
+            784,
+            121
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            126,
+            377,
+            138
+        ],
+        "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] See supplemental material.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Section 4.2 and appendix.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No]   \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] See Section 4.2 and appendix. ",
+        "bbox": [
+            240,
+            142,
+            826,
+            252
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            212,
+            256,
+            767,
+            270
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] See Section 5.   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No]   \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? [No] ",
+        "bbox": [
+            240,
+            273,
+            826,
+            372
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            212,
+            377,
+            658,
+            390
+        ],
+        "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": [
+            240,
+            393,
+            825,
+            476
+        ],
+        "page_idx": 11
+    }
+]