Add files using upload-large-folder tool

parse/train/BtZhsSGNRNi/BtZhsSGNRNi.md

@@ -0,0 +1,616 @@
+# COPING WITH LABEL SHIFT VIA DISTRIBUTIONALLY ROBUST OPTIMISATION
+
+Jingzhao Zhang   
+Massachusetts Institute of Technology   
+jzhzhang@mit.edu
+
+Aditya Krishna Menon & Andreas Veit & Srinadh Bhojanapalli & Sanjiv Kumar Google Research {adityakmenon, aveit, bsrinadh, sanjivk}@mit.edu
+
+# Suvrit Sra
+
+Massachusetts Institute of Technology suvrit@mit.edu
+
+# ABSTRACT
+
+The label shift problem refers to the supervised learning setting where the train and test label distributions do not match. Existing work addressing label shift usually assumes access to an unlabelled test sample. This sample may be used to estimate the test label distribution, and to then train a suitably re-weighted classifier. While approaches using this idea have proven effective, their scope is limited as it is not always feasible to access the target domain; further, they require repeated retraining if the model is to be deployed in multiple test environments. Can one instead learn a single classifier that is robust to arbitrary label shifts from a broad family? In this paper, we answer this question by proposing a model that minimises an objective based on distributionally robust optimisation (DRO). We then design and analyse a gradient descent-proximal mirror ascent algorithm tailored for large-scale problems to optimise the proposed objective. Finally, through experiments on CIFAR-100 and ImageNet, we show that our technique can significantly improve performance over a number of baselines in settings where label shift is present.
+
+# 1 INTRODUCTION
+
+Classical supervised learning involves learning a model from a training distribution that generalises well on test samples drawn from the same distribution. While the assumption of identical train and test distributions has given rise to useful methods, it is often violated in many practical settings (Kouw & Loog, 2018). The label shift problem is one such important setting, wherein the training distribution over the labels does not reflect what is observed during testing (Saerens et al., 2002). For example, consider the problem of object detection in self-driving cars: a model trained in one city may see a vastly different distribution of pedestrians and cars when deployed in a different city. Such shifts in label distribution can significantly degrade model performance. As a concrete example, consider the performance of a ResNet-50 model on ImageNet. While the overall error rate is $\bar { \sim } 2 4 \%$ , Figure 1 reveals that certain classes suffer an error as high as $\sim 8 0 \%$ . Consequently, a label shift that increases the prevalence of the more erroneous classes in the test set can significantly degrade performance.
+
+Most existing work on label shift operates in the setting where one has an unlabelled test sample that can be used to estimate the shifted label probabilities (du Plessis & Sugiyama, 2014; Lipton et al., 2018; Azizzadenesheli et al., 2019). Subsequently, one can retrain a classifier using these probabilities in place of the training label probabilities. While such techniques have proven effective, it is not always feasible to access an unlabelled set. Further, one may wish to deploy a learned model in multiple test environments, each one of which has its own label distribution. For example, the label distribution for a vehicle detection camera may change continuously while driving across the city. Instead of simply deploying a separate model for each scenario, deploying a single model that is robust to shifts may be more efficient and practical. Hence, we address the following question in this work: can we learn a single classifier that is robust to a family of arbitrary shifts?
+
+![](images/d5231af0b56246bc7a94d2537570ed911eb95f9facbe659051a1b1d7d0c020da.jpg)  
+Figure 1: Distribution of per-class test errors of a ResNet-50 on ImageNet (left). While the average error rate is $\sim 2 4 \%$ , some classes achieve an error as high as $\sim 8 0 \%$ . An adversary can thus significantly degrade test performance (right) by choosing $p _ { \mathrm { t e } } ( y )$ with more weight on these classes.
+
+We answer the above question by modeling label shift via distributionally robust optimisation (DRO) (Shapiro et al., 2014; Rahimian & Mehrotra, 2019). DRO offers a convenient way of coping with distribution shift, and have lead to successful applications (e.g. Faury et al. (2020)). Intuitively, by seeking a model that performs well on all label distributions that are “close” to the training data label distribution, this task can be cast as a game between the learner and an adversary, with the latter allowed to pick label distributions that maximise the learner’s loss. We remark that while adversarial perspectives have informed popular paradigms such as GANs, these pursue fundamentally different objectives from DRO (see Appendix A for details).
+
+Although several previous works have explored DRO for tackling the problem of example shift (e.g., adversarial examples) (Namkoong & Duchi, 2016; 2017; Duchi & Namkoong, 2018), an application of DRO to the label shift setting poses several challenges: (a) updating the adversary’s distribution na¨ıvely requires solving a nontrivial convex optimisation subproblem with limited tractability, and also needs careful parameter tuning; and (b) na¨ıvely estimating gradients under the adversarial distribution on a randomly sampled minibatch can lead to unstable behaviour (see §3.1). We overcome these challenges by proposing the first algorithm that successfully optimises a DRO objective for label shift on a large scale dataset (i.e., ImageNet). Our objective encourages robustness to arbitrary label distribution shifts within a KL-divergence ball of the empirical label distribution. Importantly, we show that this choice of robustness set admits an efficient and stable update step.
+
+# Summary of contributions
+
+(1) We design a gradient descent-proximal mirror ascent algorithm tailored for optimising large-scale problems with minimal computational overhead, and prove its theoretical convergence.   
+(2) With the proposed algorithm, we implement a practical procedure to successfully optimise the robust objective on ImageNet scale for the label shift application.   
+(3) We show through experiments on ImageNet and CIFAR-100 that our technique significantly improves over baselines when the label distribution is adversarially varied.
+
+# 2 BACKGROUND AND PROBLEM FORMULATION
+
+In this section we formalise the label shift problem and motivate its formulation as an adversarial optimisation problem. Consider a multiclass classification problem with distribution $p _ { \mathrm { t r } }$ over instances $\mathcal { X }$ and labels $\ Y = [ L ]$ . The goal is to learn a classifier $h _ { \theta } \colon \mathcal { X }  \mathcal { Y }$ parameterised by $\theta \in \Theta$ , with the aim of ensuring good predictive performance on future samples drawn from $p _ { \mathrm { t r } }$ . More formally, the goal is to minimise the objective $\mathrm { n i n } _ { \theta } \mathbb { E } _ { ( x , y ) \sim p _ { \mathrm { t r } } } [ \ell ( x , y , \theta ) ]$ , where $\ell \colon \mathcal { X } \times \mathcal { Y } \times \Theta  \mathbb { R } _ { + }$ is a loss function. In practice, we only have access to a finite sample $\mathcal { S } = \{ ( x _ { i } , y _ { i } ) \} _ { i = 1 } ^ { n } \sim p _ { \mathrm { t r } } ^ { n }$ , which motivates us to use the empirical distribution $\begin{array} { r } { p _ { \mathrm { e m p } } ( x , y ) = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \mathbb { 1 } ( \bar { x } = x _ { i } , \bar { y } = y _ { i } ) } \end{array}$ tr in place of $p _ { \mathrm { t r } }$ . Doing so, we arrive at the objective of minimising the empirical risk:
+
+$$
+\operatorname* { m i n } _ { \theta } \ \mathbb { E } _ { p _ { \mathrm { e m p } } } [ \ell ( x , y , \theta ) ] : = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \ell ( x _ { i } , y _ { i } , \theta ) .
+$$
+
+The assumption underlying the above formulation is that test samples are drawn from the same distribution $p _ { \mathrm { t r } }$ that is used during training. However, this assumption is violated in many practical settings. The problem of learning from a training distribution $p _ { \mathrm { t r } }$ , while attempting to perform well on a test distribution $p _ { \mathrm { t e } } \neq p _ { \mathrm { t r } }$ is referred to as domain adaptation (Ben-David et al., 2007). In the special case of label shift, one posits that $p _ { \mathrm { t e } } ( x \mid y ) = p _ { \mathrm { t r } } ( x \mid y )$ , but the label distribution $p _ { \mathrm { t e } } ( \bar { y } ) \neq p _ { \mathrm { t r } } ( y )$ (Saerens et al., 2002); i.e., the test distribution satisfies $\dot { p } _ { \mathrm { t e } } ( x , y ) = p _ { \mathrm { t e } } ( y ) p _ { \mathrm { t r } } ( x \mid y )$ . The label shift problem admits the following three distinct settings (see Table 1 for a summary):
+
+Table 1: Summary of approaches to learning with a modified label distribution.   
+
+<table><tr><td>Label distribution</td><td>Reference</td></tr><tr><td>Train distribution</td><td>Standard ERM</td></tr><tr><td>Specified a-priori (e.g., balanced)</td><td>(Elkan,2001; Xie &amp; Manski, 1989; Cao et al., 2019)</td></tr><tr><td>Estimated test distribution</td><td>(du Plessis &amp; Sugiyama, 2014; Lipton et al., 2018; Azizzadenesheli et al., 2019; Garg et al., 2020; Combes et al., 2020)</td></tr><tr><td>Worst-performing class</td><td>(Hashimoto et al., 2018; Mohri et al., 2019; Sagawa et al., 2020)</td></tr><tr><td>Worst k-performing classes</td><td>(Fan et al.,2017; Williamson &amp; Menon,2019; Curi et al.,2019; Duchi et al., 2020)</td></tr><tr><td>Adversarial shifts within KL-divergence</td><td>This paper</td></tr></table>
+
+(1) Fixed label shift. Here, one assumes $a$ -priori knowledge of $p _ { \mathrm { t e } } ( y )$ . One may then adjust the outputs of a probabilistic classifier post-hoc to improve test performance (Elkan, 2001). Even when the precise distribution is unknown, it is common to posit a uniform $p _ { \mathrm { t e } } ( y )$ . Minimising the resulting balanced error has been the subject of a large body of work (He & Garcia, 2009), with recent developments including Cui et al. (2019); Cao et al. (2019); Kang et al. (2020); Guo et al. (2020).
+
+(2) Estimated label shift. Here, we assume that $p _ { \mathrm { t e } } ( y )$ is unknown, but that we have access to an unlabelled test sample. This sample may be used to estimate $p _ { \mathrm { t e } } ( y )$ , e.g., via kernel meanmatching (Zhang et al., 2013), minimisation of a suitable KL divergence (du Plessis & Sugiyama, 2014), or using black-box classifier outputs (Lipton et al., 2018; Azizzadenesheli et al., 2019; Garg et al., 2020). One may then use these estimates to minimise a suitably re-weighted empirical risk.
+
+(3) Adversarial label shift. Here, we assume that $p _ { \mathrm { t e } } ( y )$ is unknown, and guard against a suitably defined worst-case choice. Observe that an extreme case of label shift involves placing all probability mass on a single $y ^ { \ast } \in \mathcal { Y }$ . This choice can be problematic, as (1) may be rewritten as
+
+$$
+\operatorname* { m i n } _ { \theta } \sum _ { y \in [ L ] } p _ { \mathrm { e m p } } ( y ) \cdot \bigg \{ \frac { 1 } { n _ { y } } \sum _ { i : y _ { i } = y } \ell ( x _ { i } , y _ { i } , \theta ) \bigg \} ,
+$$
+
+where $n _ { y }$ is the number of training samples with label $y$ . The empirical risk is thus a weighted average of the per-class losses. Observe that if some $y ^ { \ast } \in \mathcal { Y }$ has a large per-class loss, then an adversary could degrade performance by choosing a $p _ { \mathrm { t e } }$ with $p _ { \mathrm { t e } } ( y ^ { \ast } )$ being large. One means of guarding against such adversarial label shifts is to minimise the minimax risk (Alaiz-Rodr´ıguez et al., 2007; Davenport et al., 2010; Hashimoto et al., 2018; Mohri et al., 2019; Sagawa et al., 2020)
+
+$$
+\operatorname* { m i n } _ { \theta } \operatorname* { m a x } _ { \pi \in \Delta ^ { L } } \sum _ { y \in [ L ] } \pi ( y ) \cdot { \biggl \{ } { \frac { 1 } { n _ { y } } } \sum _ { i : \ y _ { i } = y } \ell ( x _ { i } , y _ { i } , \theta ) { \biggr \} } ,
+$$
+
+where $\Delta ^ { L }$ denotes the simplex. In (2), we combine the per-label risks according to the worst-case label distribution. In practice, focusing on the worst-case label distribution may be overly pessimistic. One may temper this by instead constraining the label distribution. A popular choice is to enforce that $\| \pi \| _ { \infty } \leq \frac { 1 } { k }$ for suitable $k$ , which corresponds to minimising the average of the top- $k$ largest per-class losses for integer $k$ (Williamson & Menon, 2019; Curi et al., 2019; Duchi et al., 2020).
+
+We focus on the adversarial label shift setting, as it meets the desiderata of training a single model that is robust to multiple label distributions, and not requiring access to test samples. Adversarial robustness has been widely studied (see Appendix A for more related work), but its application to label shift is much less explored. Amongst techniques in this area, Mohri et al. (2019); Sagawa et al. (2020) are most closely related to our work. These works optimise the worst-case loss over subgroups induced by the labels. However, both works consider settings with a relatively small $( \le 1 0 )$ number of subgroups; the resultant algorithms face many challenges when trained with many labels (see Section 4). We now detail how a suitably constrained DRO formulation, coupled with optimisation choices, can overcome this limitation.
+
+$\Delta \mathrm { l g o r i t h m 1 A D V S H I F T } ( \theta _ { 0 } , \gamma _ { c } , \lambda , \tt N N O p t , \ / p _ { \mathrm { e m p } } , \eta _ { \pi } )$   
+
+<table><tr><td colspan="2">1:Initialise adversary distribution as π1 =(,,). for t=1,...,Tdo</td></tr><tr><td>2: 3:</td><td>Sample mini-batch of b examples {(xi,yi)}=1:</td></tr><tr><td>4:</td><td>Evaluate stochastic gradient ge = 1 ∑i=1 pemp(i) 1 b πt(yi) .Vel(xi,yi,0t)</td></tr><tr><td>5:</td><td>Update neural network parameters 0t+1 = NNOpt(ge)</td></tr><tr><td>6:</td><td>Update Lagrangian variable α =Oif r &gt;KL(πt,Pemp),α = 2γc入 if r&lt;KL(πt, Pemp).</td></tr><tr><td>7:</td><td>Evaluate adversarial gradient gπ(i) = 1∑=1 Pemp() 1{yj=.Vπl(xj,yj,0t+1).</td></tr><tr><td>8:</td><td>Update adversariadistribution Tt+1= (πt : Pemp)1/(1+α）.exp(nπ)/C</td></tr></table>
+
+# 3 ALGORITHM: DISTRIBUTIONALLY ROBUST KL-DIVERGENCE MINIMISATION
+
+To address the adversarial label shift problem, we propose to replace the empirical risk (1) with
+
+$$
+\operatorname* { m i n } _ { \theta } \operatorname* { m a x } _ { \pi \in \mathcal { P } } \mathbb { E } _ { \pi } [ \ell ( x , y , \theta ) ] , \quad \mathcal { P } : = \{ \pi \in \Delta ^ { L } \mid d ( \pi , p _ { \mathrm { e m p } } ) \leq r \} ,
+$$
+
+where $\mathcal { P }$ is an uncertainty set containing perturbations of the empirical distribution $p _ { \mathrm { e m p } }$ . This is an instance of distributionally robust optimisation $( D R O )$ (Shapiro et al., 2014), a framework where one minimises the worst-case expected loss over a family of distributions. In this work, we instantiate DRO with $\mathcal { P }$ being a parameterised family of distributions with varying marginal label distributions in KL-divergence, i.e., $d ( p , q ) = \mathbb { E } _ { y \sim q } \left[ - \log p ( y ) / q ( y ) \right] .$ (We use this divergence, as opposed to a generic $f$ -divergence, as it affords closed-form updates; see $\ S 3 . 3 .$ ) Solving (3) thus directly addresses adversarial label shift, as it ensures our model performs well on arbitrary label distributions from $\mathcal { P }$ Observe further that the existing minimax risk (2) is a special case of (3) with $r = + \infty$ .
+
+Having stated our learning objective, we now turn to the issue of how to optimise it. One natural thought is to leverage strategies pursued in the literature on example-level $D R O$ using $f$ -divergences. For example, Namkoong $\&$ Duchi (2016) propose an algorithm that alternately performs iterative gradient updates for model parameters $\theta$ and adversarial distribution $\pi$ , assuming access to projection oracles, and the ability to sample from the adversarial distribution. However, there are challenges in applying such techniques on large-scale problems (e.g., ImageNet):
+
+(1) directly sampling from $\pi$ is challenging in most data loading pipelines for ImageNet. (2) projecting $\pi$ onto the feasible set $\mathcal { P }$ requires solving a constrained convex optimization problem at every iteration, which can incur non-trivial overhead (see Appendix E).
+
+We now describe ADVSHIFT (Algorithm 1), our approach to solve these problems. In a nutshell, we iteratively update model parameters $\theta$ and adversarial distributions $\pi$ . In the former, we update exactly as per ERM optimization (e.g., ADAM, SGD), which we denote as $\mathrm { N N O p t }$ (neural network optimiser); in the latter, we introduce a Lagrange multiplier to avoid projection. Extra care is needed to obtain unbiased gradients and speed up adversarial convergence, as we now detail.
+
+# 3.1 ESTIMATING THE ADVERSARIAL MINIBATCH GRADIENT
+
+For a fixed $\pi \in \Delta ^ { L }$ , to estimate the parameter gradient $\mathbb { E } _ { \pi } [ \nabla _ { \theta } \ell ( x , y , \theta ) ]$ on a training sample $\mathcal { S } = \{ ( x _ { i } , y _ { i } ) \} _ { i = 1 } ^ { n }$ , we employ the importance weighting identity and write
+
+$$
+\mathbb { E } _ { \pi } [ \nabla _ { \theta } \ell ( x , y , \theta ) ] = \mathbb { E } _ { p _ { \mathrm { e m p } } } \left[ \frac { 1 } { p _ { \mathrm { e m p } } ( y ) } \cdot \nabla _ { \theta } \ell ( x , y , \theta ) \right] = \frac { 1 } { n } \sum _ { i } \frac { \pi ( y _ { i } ) } { p _ { \mathrm { e m p } } ( y _ { i } ) } \cdot \nabla _ { \theta } \ell ( x _ { i } , y _ { i } , \theta ) .
+$$
+
+We may thus draw a minibatch as usual from S, and apply suitable weighting to obtain unbiased gradient estimates. A similar reweighting is necessary to compute the adversary gradients $\mathbb { E } _ { \pi } [ \nabla _ { \pi } \ell ( x , \bar { y } , \theta ) ]$ . Making the adversarial update efficient requires further effort, as we now discuss.
+
+# 3.2 REMOVING CONSTRAINTS BY LAGRANGIAN DUALITY
+
+To efficiently update the adversary distribution $\pi$ in (3), we would like to avoid the cost of projecting onto $\mathcal { P }$ . To bypass this difficulty, we make the following observation based on Lagrangian duality.
+
+Proposition 1. Suppose $\ell$ is bounded, and $p _ { \mathrm { e m p } }$ is not on the boundary of the simplex. Then, $\forall r > 0$ , $\exists \gamma ^ { * } > 0$ such that for every $\gamma _ { c } \geq \gamma ^ { * }$ , the constrained objective is solvable in unconstrained form:
+
+$$
+\operatorname * { a r g m a x } _ { \pi \in \Delta L , { \mathrm { \tiny ~ K L } } ( \pi , p _ { \mathrm { c m p } } ) \leq r } \mathbb { E } _ { \pi } [ \ell ( x , y , \theta ) ] = \operatorname * { a r g m a x } _ { \pi \in \Delta L } \mathbb { E } _ { \pi } [ \ell ( x , y , \theta ) ] + \operatorname* { m i n } \{ 0 , \gamma _ { c } ( r - \mathrm { K L } ( \pi , p _ { \mathrm { e m p } } ) ) \} .
+$$
+
+Motivated by this, we may thus transform the objective (3) into:
+
+$$
+\operatorname* { m i n } _ { \theta } \operatorname* { m a x } _ { \pi \in \Delta ^ { L } } \mathbb { E } _ { \pi } [ \ell ( x , y , \theta ) ] + \operatorname* { m i n } \{ 0 , \gamma _ { c } ( r - \mathrm { K L } ( \pi , p _ { \mathrm { e m p } } ) ) \} ,
+$$
+
+where $\gamma _ { c } > 0$ is a sufficiently large constant; in practice, this may be chosen by a bisection search.   
+The advantage of this formulation is that it admits an efficient update for $\pi$ , as we now discuss.
+
+# 3.3 ADVERSARIAL DISTRIBUTION UPDATES
+
+We now detail how we can employ proximal mirror descent to efficiently update $\pi$ . Observe that we may decompose the adversary’s (negated) objective into two terms: $f ( \theta , \pi ) : = - \mathbb { E } _ { \pi } [ \ell ( x , y , \theta ) ]$ and $h ( \pi ) : = \bar { \operatorname* { m a x } } \{ 0 , \gamma _ { c } ( \mathrm { K L } ( \pi , p _ { \mathrm { e m p } } ) ^ { } - r ) \}$ , where $h ( \pi )$ is independent of the samples. Such decomposable objectives suggest using proximal updates (Combettes & Pesquet, 2011):
+
+$$
+\pi _ { t + 1 } = \mathrm { p r o x } _ { \lambda h } ( \pi _ { t } - \lambda \nabla _ { \pi } f ( \theta _ { t } , \pi _ { t } ) ) : = \underset { \pi \in \Delta ^ { L } } { \mathrm { a r g m i n } } h ( \pi ) + \frac { 1 } { 2 \lambda } ( \| \pi _ { t } - \pi \| ^ { 2 } + 2 \lambda \langle \nabla _ { \pi } f ( \theta _ { t } , \pi _ { t } ) , \pi \rangle ) ,
+$$
+
+where $\lambda$ serves as the learning rate. The value of proximal descent relies on the ability to efficiently solve the minimisation problem in (5). Unfortunately, this does not hold as-is for our choice of $h ( \pi )$ , essentially due to a mismatch between the use of KL-divergence in $h$ , and Euclidean distance $\| \dot { \pi } _ { t } - \pi \| ^ { 2 }$ in (5). Motivated by the advantages of mirror descent over gradient descent on the simplex (Bubeck, 2014), we propose to replace the Euclidean distance with KL-divergence:
+
+$$
+\pi _ { t + 1 } = \operatorname * { a r g m i n } _ { \pi \in \Delta ^ { L } } h ( \pi ) + \frac { 1 } { 2 \lambda } ( \mathrm { K L } ( \pi , \pi _ { t } ) + 2 \lambda \langle g _ { t } , \pi \rangle ) ,
+$$
+
+where $g _ { t }$ is an unbiased estimator of $\nabla _ { \pi } f ( \theta _ { t } , \pi _ { t } )$ . We have the following closed-form update.
+
+Lemma 2. Assume the optimal solution $\pi _ { t + 1 }$ to (6) satisfies $\mathrm { K L } ( \pi _ { t + 1 } , p _ { \mathrm { e m p } } ) \neq r$ , and that all the classes appeared at least once in the empirical distribution, i.e. $\forall i , p _ { \mathrm { e m p } } ^ { i } > 0$ . Let $\gamma = \gamma _ { c } i f r <$ $\mathrm { K L } ( \pi _ { t + 1 } , p _ { \mathrm { e m p } } )$ , and $\gamma = 0$ if $r > \mathrm { K L } ( \pi _ { t + 1 } , p _ { \mathrm { e m p } } )$ , then $\pi _ { t + 1 }$ permits a closed form solution
+
+$$
+\pi _ { t + 1 } = ( \pi _ { t } \odot p _ { \mathrm { e m p } } ^ { \alpha } ) ^ { 1 / ( 1 + \alpha ) } \exp { ( \eta _ { \pi } g _ { t } ) / C } ,
+$$
+
+where $\begin{array} { r } { \eta _ { \pi } = \frac { 1 } { ( \gamma + 1 / 2 \lambda ) ( 1 + \alpha ) } } \end{array}$ , $\alpha = 2 \gamma \lambda$ , $C = \| ( \pi _ { t } \odot p _ { \mathrm { e m p } } ^ { \alpha } ) ^ { 1 / ( 1 + \alpha ) } \exp \left( \eta _ { \pi } g _ { t } \right) \| _ { 1 }$ projects $\pi _ { t + 1 }$ onto the simplex, and $a \odot b$ is the element-wise product between two vectors $a , b$ .
+
+In Algorithm 1, we set $\gamma = \gamma _ { c }$ if $r < \mathrm { K L } ( \pi _ { t } , p _ { \mathrm { e m p } } )$ and 0 otherwise to appoximate the true $\gamma$ . Such approximation works well when $r - \mathrm { K L } ( \pi _ { t } , p _ { \mathrm { e m p } } )$ does not change sign frequently.
+
+# 3.4 CONVERGENCE ANALYSIS
+
+We provide below a convergence analysis of our gradient descent-proximal mirror ascent method for nonconvex-concave stochastic saddle point problems. For the composite objective $\begin{array} { r } { \operatorname* { m i n } _ { \theta } \operatorname* { m a x } _ { \pi \in \Delta ^ { L } } f ( \theta , \pi ) + h ( \pi ) } \end{array}$ , and fixed learning rate $\eta _ { \theta }$ , we abstract the Algorithm 1 update as:
+
+$$
+\theta _ { t + 1 } = \theta _ { t } - \eta _ { \theta } g ( \theta _ { t } ) , \quad \pi _ { t + 1 } = \operatorname * { a r g m a x } _ { \pi } h ( \pi ) - \frac { 1 } { 2 \lambda } ( \mathrm { K L } ( \pi , \pi _ { t } ) + 2 \lambda \langle g ( \pi _ { t } ) , \pi \rangle ) ,
+$$
+
+where $g ( \pi ) , g ( \theta )$ are stochastic gradients assumed to satisfy the following.
+
+Assumption 1. The stochastic gradient $g ( \theta )$ with respect to $\theta$ satisfies that for some $\sigma > 0$
+
+$$
+\begin{array} { r } { \mathbb { E } [ g ( \theta ) ] = \nabla _ { \theta } f ( \theta , \pi ) , \mathrm { ~ a n d ~ } \mathbb { E } [ \| g ( \theta ) - \mathbb { E } [ g ( \theta ) ] \| ^ { 2 } ] \le \sigma ^ { 2 } . } \end{array}
+$$
+
+Assumption 2. The stochastic gradient $g ( \pi )$ with respect to $\pi$ satisfies that for some $G > 0$ ,
+
+$$
+\begin{array} { r } { \mathbb { E } [ g ( \pi ) ] = \nabla _ { \pi } f ( \theta , \pi ) , \ \mathrm { a n d } \ \mathbb { E } [ \| g ( \pi ) \| _ { \infty } ^ { 2 } ] \leq G ^ { 2 } . } \end{array}
+$$
+
+We make the following assumptions about the objective, similar to Lin et al. (2019; 2020):
+
+Assumption 3. $f ( \theta , \pi ) + h ( \pi )$ is $L -$ smooth and l−Lipschitz; $f ( \theta , \pi )$ and $h ( \pi )$ are concave in $\pi$ . Assumption 4. Every adversarial distribution iterate $\pi _ { t }$ satisfies $\mathrm { K L } ( \pi _ { t } , p _ { \mathrm { e m p } } ) \leq R$ for some $R > 0$
+
+Assumption 3 and 4 may be enforced by adding a constant $\epsilon$ to the adversarial updates, which prevents $\pi _ { t }$ from approaching the boundary of the simplex. Assumption 2 in the label shift setting implies that the loss is upper and lower bounded. Such an assumption may be enforced by clipping the loss for computing the adversarial gradient, which can significantly speed up training (see Appendix ??). Furthermore, this is a standard assumption for analyzing nonconvex-concave problems (Lin et al., 2019). The assumption that the square $L _ { \infty }$ norm is bounded is weaker than $L _ { 2 }$ norm being bounded; such a relaxation results from using mirror rather than Euclidean update.
+
+Given that the function $F ( \theta ) : = \operatorname* { m a x } _ { \pi \in \Delta } f ( \theta , \pi ) + h ( \pi )$ is nonconvex, our goal is to find a stationary point instead of approximating global optimum. Yet, due to the minimax formulation, the function $F ( \theta )$ may not necessarily be differentiable. Hence, we define convergence following some recent works (Davis & Drusvyatskiy, 2019; Lin et al., 2019; Thekumparampil et al., 2019) on nonconvexconcave optimisation. First, Assumption 3 implies $F ( \theta )$ is $L -$ weakly convex and $l$ -Lipschitz (Lin et al., 2019, Lemma 4.7). Hence, we define stationarity in the language of weakly convex functions.
+
+Definition 1. A point $\theta$ is an $\epsilon -$ stationary point of a weakly convex function $F$ if $\| \nabla F _ { 1 / 2 L } ( \theta ) \| \le \epsilon .$ where $F _ { 1 / 2 L } ( \theta )$ denotes the Moreau envelope $\begin{array} { r } { F _ { 1 / 2 L } ( \theta ) = \mathrm { m i n } _ { w } F ( w ) + L \| w - \theta \| ^ { 2 } } \end{array}$ .
+
+With the above definition, we can establish convergence of the following update:
+
+Theorem 3 (informal). Under Assumptions 1–4, the update in (8) finds a point $\theta$ with $\mathbb { E } [ \| \nabla F _ { \frac { 1 } { 2 L } } ( \theta ) \| ] \le \epsilon$ in $\mathcal { O } ( \epsilon ^ { - 8 } )$ iterations.
+
+For a precise description of the theorem, please see Appendix H. The above result matches the best known rate in Lin et al. (2019) for optimising nonconvex-concave problem with stochastic gradients. To our knowledge, this is the first result that studies convergence of composite objectives with proximal methods under nonconvex-concave settings. By utilizing the proximal operator, it solves the objective with an extra $h ( \pi )$ term without incurring additional complexity cost.
+
+# .5 CLIPPING AND REGULARISING FOR FASTER CONVERGENCE
+
+In addition to the proposed algorithm, we apply two additional techniques. We explain them here with motivations. First, we also observe that the adversarial’s update could be very sensitive to the adversarial gradient $g _ { k }$ , i.e. label-wise loss in each minibatch, because the gradient appears in the exponential of the update. To avoid convergence degradation resulted from the noise in $g _ { k }$ , we clip the label-wise loss at value 2. Second, we notice that the KL divergence from any interior point of a simplex to its boundary is infinity. Hence, updates near boundary can be highly unstable due to the nonsmooth KL loss. To cope with this, we add a constant $\epsilon$ term on the adversarial distribution to avoid the adversarial distribution reaching any of the vertices on the simplex. The $\epsilon$ term and clipping is critical in both training and convergence analysis. We conduct an ablation of the sensitivity to these parameters in Figures 5 and 6. Note that the experiments show that even without these tricks, our proposed algorithm alone still outperform baselines.
+
+# 3.6 DISCUSSION AND COMPARISON TO EXISTING ALGORITHMS
+
+A number of existing learning paradigms (e.g., fairness, adversarial training, and domain adaptation) have connections to the problem of adversarial label shift; see Appendix A for details.
+
+We comment on some key differences between ADVSHIFT and related techniques in the literature. For the problem of minimising the worst-case loss (2) — which is equivalent to setting the radius $r = + \infty$ in (3) — Sagawa et al. (2020) propose an algorithm that assumes the ability to sample data from a given group in order to evaluate adversarial gradients. Such sampling is cumbersome to implement in most ImageNet data loading pipelines. Mohri et al. (2019) propose a way to evaluate gradients using importance sampling, and then apply projected gradient descent-ascent. This method suffers from instability owing to sampling (upon which we improve with proximal updates), and incurs a non-trivial computational overhead due to the projection step. We will illustrate these problems in our subsequent experiments (see results for AGNOSTIC in $\ S \ O $ ). Finally, for an uncertainty set $\mathcal { P }$ based on the CVaR, Curi et al. (2019) provide an algorithm that updates weights using EXP3. This approach relies on a determinantal point process, which has a poor dimension-dependence.
+
+![](images/bd060e946aeec34579e27012cc1429007d2e585fb4aa017b5179722123f08d23.jpg)  
+Figure 2: Comparison of performance on ImageNet under adversarial label distributions. For each method, we vary the KL divergence threshold $\tau$ , and for each $\tau$ report the maximal validation error induced by the adversarial shift within the threshold. Subplots (a) (b) compare the performance of ADVSHIFT trained with different DRO radius $r$ against the default ERM training. We subtract the baseline error of ERM from all values for easy visualization. Absolute values can be found in Figure 8 in the Appendix. Combined with (c), (d), we see that ADVSHIFT can reduce the adversarial validation error by over $\sim 2 . 5 \%$ compared to the BASELINE method and is consistently superior to the AGNOSTIC, BALANCED and FIXED methods. Figure 3(c) illustrates adversarial distributions for varying thresholds $\tau$ .
+
+# 4 EXPERIMENTAL RESULTS
+
+We now present a series of experiments to evaluate the performance of the proposed ADVSHIFT algorithm and how it compares to related approaches from the literature. We first explain our experiment setups and evaluation methods. We then present the results on ImageNet dataset, and show that under the adversarial validation setting, our proposed algorithm significantly outperforms other methods discussed in Table 1. Similar results on CIFAR-100 are shown in the Appendix.
+
+# 4.1 EXPERIMENTAL SETUP
+
+To evaluate the proposed method, we use the standard image classification setup of training a ResNet50 on ImageNet using SGD with momentum as the neural network optimiser. All algorithms are run for 90 epochs, and are found to take almost the same clock time. Note that ImageNet has a largely balanced training label distributions, and perfectly balanced validation label distributions.
+
+We assess the performance of models under adversarial label shift as follows. First, we train a model on the training set and compute its error distribution on the validation set. Next, we pick a threshold $\tau$ on the allowable KL divergence between the train and target distribution and find the adversarial distribution within this threshold which achieves the worst-possible validation error. Finally, we compute the validation performance under this distribution. Note that $\tau = 0$ corresponds to the train distribution, while $\tau = + \infty$ corresponds to the worst-case label distribution (see Figure 1).
+
+We evaluate the following methods, each corresponding to one row in Table 1: (i) standard empirical risk minimisation (BASELINE) (ii) balanced empirical risk minimisation (BALANCED) (iii) agnostic federated learning algorithm of Mohri et al. (2019), which minimises the worst-case loss (AGNOSTIC) (iv) our proposed KL-divergence based algorithm, for various choices of adversarial radius $r$ (ADVSHIFT) (v) training with ADVSHIFT with a fixed adversarial distribution extracted from Figure 3(c) (FIXED). This corresponds to the estimated test distribution row in Table 1 with an ideal estimator.
+
+# 4.2 RESULTS AND DISCUSSION
+
+Figure 2 shows the train and validation performance on ImageNet. Each curve represents the average and standard deviation across 10 independent trials. To better illustrate the differences amongst methods, we plot the difference in error to the BASELINE method. (See Figure 8 in the Appendix for unnormalised plots.) Subfigures (a) and (b) compre the performance of ADVSHIFT for various choices of radius $r$ to the ERM baseline; (c) and (d) compare ADVSHIFT to the remaining methods.
+
+![](images/d0972a62dbacdf91096b72ea52e590c9fde2b7d2c0a645535fd27ae0e3844d9a.jpg)
+
+![](images/a56805e8b54572eb762726077a3a6a6dd4345b75740409610bb307993378fbf2.jpg)  
+Figure 3: Subplots (a) (b) show violin plots of the distribution of errors for both the BASELINE and our ADVSHIFT methods over the course of training. On the training set, ADVSHIFT significantly reduces the worst-case error, evidenced by lower upper endpoints of the distribution. On the validation set, the reduction is consistent, albeit less pronounced owing to a generalisation gap. Subplot (c) illustrates adversarial distributions at KL distances of 1, 2 and 3 for model trained with BASELINE. Even at $\tau = 1$ , the adversarial distribution is highly concentrated on only a few hard labels.   
+Figure 4: Evolution of learned adversarial distribution $( \pi )$ across training epochs. Starting off from a uniform distribution over labels, the adversary quickly infers the relative difficulty of a small fraction of labels, assigning nearly $2 \times$ the weight on them compared to the average. This distribution remains largely stable in subsequent iterations, getting gradually more concentrated as training converges.
+
+Hyperparameters for each method are separately tuned. FIXED 1, 2, 3 corresponds to training with each of the three adversarial distributions in Figure 3(c). We see that:
+
+• the reduction offered by ADVSHIFT is consistently superior to that afforded by the AGNOSTIC, BALANCED and FIXED methods. On the training set, we observe significant $( \sim 8 \%$ ) reduction in performance for large KL divergence thresholds. On the validation set, the gains are less pronounced $( \sim 2 . 5 \% )$ , indicating some degradation due to a generalisation gap. while ADVSHIFT consistently improves above the baseline across adversarial radii, we observe best performance for $r = 0 . 1$ . Smaller values of $r$ lead to smaller improvements, while training becomes increasingly unstable for larger radii. Please see the discussion in the last section. • during training, AGNOSTIC either learns the adversarial distribution too slowly (such that it behaves like ERM), or uses too large a learning rate for the adversary (such that the training fails). This highlights the importance of the proximal mirror ascent updates in our algorithm.
+
+Illustration of distributions at fixed KL thresholds. Figure 3(c) visualises the adversarial distributions corresponding to a few values of the KL threshold $\tau$ . At a threshold of $\tau = 3$ , the adversarial distribution is concentrated on only a few hard labels. Consequently, the resulting performance on such distributions is highly reflective of the worst-case distribution that can happen in reality.
+
+Training with a fixed adversarial distribution. Suppose we take the final adversarial distributions shown in Figure 3(c), and then employ them as fixed distributions during training; this corresponds to the specified a-priori and estimated validation distribution approaches in Table 1. Does the resulting model similarly reduce the error on hard classes? Surprisingly, Figure 2(d) indicates this is not so, and performance is in fact significantly worse on the “easy” classes. Employing a fixed adversarial distribution may thus lead to underfitting, which has an intuitive explanation: the model must struggle to fit difficult patterns from early stages of training. Similar issues with importance weighting in conjunction with neural networks have been reported in Byrd & Lipton (2019).
+
+Evolution of error distributions. To dissect the evolution of performance during training, Figure 3 shows violin plots of the distribution of errors for both the BASELINE and our ADVSHIFT methods after fixed training epochs. We observe that on the training set, ADVSHIFT significantly reduces the worst-case error, evidenced by the upper endpoints of the distribution being reduced. Note also that, as expected, the adversarial algorithm is slower to reduce the error on the “easy” classes early in training, evidenced by the lower endpoints of the distribution initially taking higher values. On the validation set, the reduction is consistent, albeit less pronounced owing to a generalisation gap.
+
+![](images/ba926640db87c4f5979005fe8e78d890cc4d046b35521466d363ad71385950ae.jpg)  
+Figure 5: Ablation of loss clipping threshold. We see that when the clipping threshold is either too large or too small, validation performance of the model tends to suffer.
+
+![](images/a31cf2fa1f54c02267afad99f761807a44b9c79901c8f5cbae7de4fe0f119724.jpg)  
+Figure 6: Ablation of gradient stabilisation parameter $\epsilon$ , which is a constant added to the gradient updates to prevent iterates from reaching the vertices of the simplex. We see that without any gradient stabilisation, the model’s performance rapidly degrades as the adversarial radius increases. Conversely, performance also suffers when the stablisation is too high.
+
+Evolution of learned adversarial weights. To understand the evolution of the adversarial distribution across training epochs, Figure 4 plots the histogram of adversary weights at fixed training epochs. Starting off from a uniform distribution, the adversary is seen to quickly infer the relative difficulty of a small fraction of labels, assigning $\sim 2 \times$ the weight on them compared to the average. In subsequent iterations the distribution becomes more concentrated, and gradually reduces the largest weights.
+
+# Ablation of clipping threshold and gradient stabiliser.
+
+Figures 5 and 6 show an ablation of the choice of loss clipping threshold, and the gradient stabiliser . We see that when the clipping threshold is either too large or too small, validation performance of the model tends to suffer (albeit still better than the baseline). Similarly, we see that without any gradient stabilisation, the model’s performance rapidly degrades as the adversarial radius increases. Conversely, performance also suffers when the stablisation is too high.
+
+In summary, our experiments show that our proposed DRO formulation can be effectively solved with ADVSHIFT, and results in a model that is robust to adversarial label shift.
+
+# 5 DISCUSSION AND FUTURE WORK
+
+We proposed ADVSHIFT, an algorithm for coping with label shift based on distributionally robust optimisation, and illustrated its effectiveness of real-world datasets. Despite this, our approach does not solve the problem fully. First, Figure 2(a)(b) shows that the generalization gap increases as the perturbation radius increases. Understanding why there is a correlation between hard examples and bad generalization could improve robustness. Second, Figure 2(a) shows that even on the train set, the algorithm threshold $r$ does not translate to the model’s level of robustness. We conjecture this results from the interplay of model expressivity and data distribution, whose future study is of interest.
+
+# REFERENCES
+
+Roc´ıo Alaiz-Rodr´ıguez, Alicia Guerrero-Curieses, and Jesus Cid-Sueiro. Minimax regret classifier ´ for imprecise class distributions. Journal of Machine Learning Research, 8:103–130, May 2007. ISSN 1532-4435.
+
+Martin Arjovsky, Leon Bottou, Ishaan Gulrajani, and David Lopez-Paz. Invariant risk minimization, ´ 2019.
+
+Kamyar Azizzadenesheli, Anqi Liu, Fanny Yang, and Animashree Anandkumar. Regularized learning for domain adaptation under label shifts. In International Conference on Learning Representations, 2019.
+
+Shai Ben-David, John Blitzer, Koby Crammer, and Fernando Pereira. Analysis of representations for domain adaptation. In Advances in neural information processing systems, pp. 137–144, 2007.
+
+Sebastien Bubeck. Convex optimization: Algorithms and complexity, 2014. ´
+
+Jonathon Byrd and Zachary Chase Lipton. What is the effect of importance weighting in deep learning? In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, volume 97 of Proceedings of Machine Learning Research, pp. 872–881. PMLR, 2019.
+
+Kaidi Cao, Colin Wei, Adrien Gaidon, Nikos Arechiga, and Tengyu Ma. Learning imbalanced datasets with label-distribution-aware margin loss. In Advances in Neural Information Processing Systems, 2019.
+
+Remi Tachet des Combes, Han Zhao, Yu-Xiang Wang, and Geoff Gordon. Domain adaptation with conditional distribution matching and generalized label shift. arXiv preprint arXiv:2003.04475, 2020.
+
+Patrick L Combettes and Jean-Christophe Pesquet. Proximal splitting methods in signal processing. In Fixed-point algorithms for inverse problems in science and engineering, pp. 185–212. Springer, 2011.
+
+Yin Cui, Menglin Jia, Tsung-Yi Lin, Yang Song, and Serge Belongie. Class-balanced loss based on effective number of samples. In CVPR, 2019.
+
+Sebastian Curi, Kfir. Y. Levy, Stefanie Jegelka, and Andreas Krause. Adaptive sampling for stochastic risk-averse learning, 2019.
+
+M. A. Davenport, R. G. Baraniuk, and C. D. Scott. Tuning support vector machines for minimax and neyman-pearson classification. IEEE Transactions on Pattern Analysis and Machine Intelligence, 32(10):1888–1898, 2010.
+
+Damek Davis and Dmitriy Drusvyatskiy. Stochastic model-based minimization of weakly convex functions. SIAM Journal on Optimization, 29(1):207–239, 2019.
+
+Michele Donini, Luca Oneto, Shai Ben-David, John Shawe-Taylor, and Massimiliano Pontil. Empirical risk minimization under fairness constraints. In Proceedings of the 32nd International Conference on Neural Information Processing Systems, NIPS’18, pp. 2796–2806, Red Hook, NY, USA, 2018. Curran Associates Inc.
+
+Marthinus Christoffel du Plessis and Masashi Sugiyama. Semi-supervised learning of class balance under class-prior change by distribution matching. Neural Networks, 50:110–119, 2014.
+
+J. Duchi and H. Namkoong. Learning models with uniform performance via distributionally robust optimization. arXiv preprint arXiv:1810.08750, 2018.
+
+John Duchi, Tatsunori Hashimoto, and Hongseok Namkoong. Distributionally robust losses for latent covariate mixtures, 2020.
+
+Charles Elkan. The foundations of cost-sensitive learning. In Proceedings of the 17th International Joint Conference on Artificial Intelligence - Volume 2, IJCAI’01, pp. 973–978, San Francisco, CA, USA, 2001. Morgan Kaufmann Publishers Inc. ISBN 1558608125.
+
+Yanbo Fan, Siwei Lyu, Yiming Ying, and Baogang Hu. Learning with average top-k loss. In Advances in neural information processing systems, pp. 497–505, 2017.
+
+Louis Faury, Ugo Tanielian, Elvis Dohmatob, Elena Smirnova, and Flavian Vasile. Distributionally robust counterfactual risk minimization. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pp. 3850–3857, 2020.
+
+Saurabh Garg, Yifan Wu, Sivaraman Balakrishnan, and Zachary C. Lipton. A unified view of label shift estimation, 2020.
+
+Ian J. Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron C. Courville, and Yoshua Bengio. Generative adversarial nets. In Zoubin Ghahramani, Max Welling, Corinna Cortes, Neil D. Lawrence, and Kilian Q. Weinberger (eds.), Advances in Neural Information Processing Systems 27: Annual Conference on Neural Information Processing Systems 2014, December 8-13 2014, Montreal, Quebec, Canada, pp. 2672–2680, 2014.
+
+Jiaxian Guo, Mingming Gong, Tongliang Liu, Kun Zhang, and Dacheng Tao. Ltf: A label transformation framework for correcting label shift. In International Conference on Machine Learning, pp. 3843–3853. PMLR, 2020.
+
+Tatsunori Hashimoto, Megha Srivastava, Hongseok Namkoong, and Percy Liang. Fairness without demographics in repeated loss minimization. In Jennifer Dy and Andreas Krause (eds.), International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 1929–1938, Stockholmsmassan, Stockholm Sweden, 10–15 Jul 2018. PMLR. ¨
+
+Haibo He and Edwardo A. Garcia. Learning from imbalanced data. IEEE Transactions on Knowledge and Data Engineering, 21(9):1263–1284, 2009.
+
+Weihua Hu, Gang Niu, Issei Sato, and Masashi Sugiyama. Does distributionally robust supervised learning give robust classifiers? In Jennifer G. Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan, ¨ Stockholm, Sweden, July 10-15, 2018, volume 80 of Proceedings of Machine Learning Research, pp. 2034–2042. PMLR, 2018.
+
+Bingyi Kang, Saining Xie, Marcus Rohrbach, Zhicheng Yan, Albert Gordo, Jiashi Feng, and Yannis Kalantidis. Decoupling representation and classifier for long-tailed recognition. In Eighth International Conference on Learning Representations (ICLR), 2020.
+
+Wouter M. Kouw and Marco Loog. An introduction to domain adaptation and transfer learning. CoRR, abs/1812.11806, 2018. URL http://arxiv.org/abs/1812.11806.
+
+Daniel Levy, Yair Carmon, John C Duchi, and Aaron Sidford. Large-scale methods for distributionally robust optimization. Advances in Neural Information Processing Systems, 33, 2020.
+
+Tianyi Lin, Chi Jin, and Michael I. Jordan. On gradient descent ascent for nonconvex-concave minimax problems, 2019.
+
+Tianyi Lin, Chi Jin, and Michael. I. Jordan. Near-optimal algorithms for minimax optimization, 2020.
+
+Zachary Lipton, Yu-Xiang Wang, and Alexander Smola. Detecting and correcting for label shift with black box predictors. In Jennifer Dy and Andreas Krause (eds.), International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 3122–3130, Stockholmsmassan, Stockholm Sweden, 10–15 Jul 2018. PMLR. ¨
+
+Mehryar Mohri, Gary Sivek, and Ananda Theertha Suresh. Agnostic federated learning. In International Conference on Machine Learning, 2019.
+
+Krikamol Muandet, David Balduzzi, and Bernhard Scholkopf. Domain generalization via invariant ¨ feature representation. In Sanjoy Dasgupta and David McAllester (eds.), International Conference on Machine Learning, Proceedings of Machine Learning Research, pp. 10–18, Atlanta, Georgia, USA, 17–19 Jun 2013. PMLR.
+
+H. Namkoong and J. Duchi. Stochastic gradient methods for distributionally robust optimization with f-divergences. In Advances in Neural Information Processing Systems (NeurIPS), 2016.
+
+Hongseok Namkoong and John C Duchi. Variance-based regularization with convex objectives. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 2971–2980. Curran Associates, Inc., 2017.
+
+Hamed Rahimian and Sanjay Mehrotra. Distributionally robust optimization: A review, 2019.
+
+Marco Saerens, Patrice Latinne, and Christine Decaestecker. Adjusting the outputs of a classifier to new a priori probabilities: A simple procedure. Neural Computation, 14(1):21–41, 2002.
+
+S. Sagawa, P. W. Koh, T. B. Hashimoto, and P. Liang. Distributionally robust neural networks for group shifts: On the importance of regularization for worst-case generalization. In International Conference on Learning Representations (ICLR), 2020.
+
+Alexander Shapiro, Darinka Dentcheva, and Andrzej Ruszczynski. ´ Lectures on Stochastic Programming: Modeling and Theory, Second Edition. Society for Industrial and Applied Mathematics, Philadelphia, PA, 2014. doi: 10.1137/1.9781611973433.
+
+Aman Sinha, Hongseok Namkoong, and John Duchi. Certifying some distributional robustness with principled adversarial training. arXiv preprint arXiv:1710.10571, 2017.
+
+Aman Sinha, Hongseok Namkoong, and John Duchi. Certifiable distributional robustness with principled adversarial training. In International Conference on Learning Representations, 2018.
+
+Amos J Storkey and Masashi Sugiyama. Mixture regression for covariate shift. In B. Scholkopf,¨ J. C. Platt, and T. Hoffman (eds.), Advances in Neural Information Processing Systems 19, pp. 1337–1344. MIT Press, 2007.
+
+Kiran Koshy Thekumparampil, Prateek Jain, Praneeth Netrapalli, and Sewoong Oh. Efficient algorithms for smooth minimax optimization, 2019.
+
+Robert C. Williamson and Aditya Krishna Menon. Fairness risk measures. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, pp. 6786–6797, 2019.
+
+Yu Xie and Charles F. Manski. The logit model and response-based samples. Sociological Methods & Research, 17(3):283–302, 1989.
+
+Muhammad Bilal Zafar, Isabel Valera, Manuel Gomez Rodriguez, and Krishna P. Gummadi. Fairness beyond disparate treatment & disparate impact: Learning classification without disparate mistreatment. In Proceedings of the 26th International Conference on World Wide Web, WWW ’17, pp. 1171–1180, Republic and Canton of Geneva, CHE, 2017. International World Wide Web Conferences Steering Committee. ISBN 9781450349130.
+
+Kun Zhang, Bernhard Scholkopf, Krikamol Muandet, and Zhikun Wang. Domain adaptation under ¨ target and conditional shift. In Proceedings of the 30th International Conference on International Conference on Machine Learning - Volume 28, ICML’13, pp. III–819–III–827. JMLR.org, 2013.
+
+# A RELATED PROBLEMS
+
+Example-level DRO. Existing work on DRO has largely focussed on the setting where $\mathcal { P }$ encompasses shifts in the instance space (Namkoong & Duchi, 2016; 2017; Sinha et al., 2018; Duchi & Namkoong, 2018; Levy et al., 2020). This notion of robustness has a natural link with adversarial training (Sinha et al., 2017), and involves a more challenging problem, as it requires parameterising the adversary’s distribution. Hu et al. (2018) illustrate the potential pitfalls of DRO, owing to a mismatch between surrogate and 0-1 losses. They also propose to encode an uncertainty set based on latent label distribution shift (Storkey & Sugiyama, 2007), which requires domain knowledge. The techniques in example-level DRO are mostly designed for small scale dataset with SVM models, as these techniques require sampling according to adversarial distribution, which can be very unstable if implemented with importance sampling only. It also requires maintaining a vector proportional to the number of labels and indexing each sample during training to match up the sample index, which is not available in most dataloading pipelines.
+
+Fairness. Adversarial label shift may be related to algorithmic fairness. Abstractly, this concerns the mitigation of systematic bias in predictions on sensitive subgroups (e.g., country of origin). One fairness criteria posits that the per-subgroup errors should be equal (Zafar et al., 2017; Donini et al., 2018), an ideal that may be targetted by minimising the worst-subgroup error (Mohri et al., 2019; Sagawa et al., 2020). When the subgroups correspond to labels, ensuring this notion of fairness is tantamount to guarding against an adversary that can place all mass on the worst performing label.
+
+GANs. GANs (Goodfellow et al., 2014) involve solving a min-max objective that bears some similarity to the DRO formulation (3), but is fundamentally different in details: while DRO considers reweighting of samples according to a fixed family, GANs involve a parameterised adversarial family, with the training objective augmented with an additional penalty.
+
+Domain adaptation. Label shift can be viewed as a special case of domain adaptation, where $p _ { \mathrm { t r } }$ and $p _ { \mathrm { t e } }$ can systematically differ. Typically, one assumes access to a small sample from $p _ { \mathrm { t e } }$ , which may be used to estimate importance weights (Combes et al., 2020), or samples from multiple domains, which may be used to estimate a generic domain-agnostic representation (Muandet et al., 2013). In causal inference, there has been interest in similar classes of models (Arjovsky et al., 2019).
+
+# B ALGORITHM IMPLEMENTATION DETAILS
+
+We introduce some additional details in our implementation of ADVSHIFT. First, as observed in Section 3.1, our algorithm requires knowing the empirical label distribution. As the exact value is not always available, we estimate the empirical label distribution online for all the experiments presented later in Section 4 using an exponential moving average, $p _ { \mathrm { e m p } } = \beta \cdot p _ { \mathrm { e m p } } + ( 1 - \beta ) \cdot p _ { \mathrm { b a t c h } }$ , where $p _ { \mathrm { b a t c h } }$ is the label distribution in the minibatch. We set $\beta = 0 . 9 9 9$ . The number is set such that the exponential moving average has a half-life roughly equal to the number of iterations in one epoch of ImageNet training using our setup.
+
+In all the experiments, we set $2 \gamma _ { c } \lambda = 1$ in Algorithm 1 for simplicity. For learning the adversarial distribution, we only tune the adversarial learning rate $\eta _ { \pi }$ .
+
+# C ADDITIONAL EXPERIMENTAL RESULTS
+
+We present here additional experimental results, including:
+
+• for ImageNet, an illustration of the lack of correlation between a label’s frequency in the training set, and its validation error. (Figure 7) unnormalised versions of the results on ImageNet shown in the body, where we do not subtract the baseline performance from each of the curves; this gives a sense of the absolute performance numbers obtained by each method. (Figure 8)   
+• an ablation of the loss clipping threshold and gradient stabiliser $\epsilon$ as introduced above. (Figure 5,6)   
+• results on CIFAR-100, to complement those for ImageNet. (Figure 9,10)
+
+![](images/a520e8b289893455646126cfd5ca63e844157e7dcdaa15105a6be6f5a79a7806.jpg)  
+Figure 7: Illustration that training label frequency does not strongly correlate with test error. Observe that several classes with a high error appear frequently in the training set.
+
+![](images/86d4b0e48f8565e0e2549c4dc207d0b33c9bd820cd3d5fcc24e8241af0af2c6e.jpg)  
+Figure 8: Comparison of performance of various methods on ImageNet under adversarial label distributions. For each plot, we vary a KL divergence threshold $\tau$ , and for a given $\tau$ construct the label distribution which results in maximal test error for the baseline model. We then compute the test error under this distribution. Note that the case $\tau = 0$ corresponds to using the train distribution, while $\tau = + \infty$ corresponds to using the worst-case label distribution, which is concentrated on the worst-performing label. Our proposed ADVSHIFT can reduce the adversarial test error by over $\sim 2 . 5 \%$ over the baseline method.
+
+# C.1 BALANCED LABELS $\nRightarrow$ BALANCED PERFORMANCE
+
+Figure 7 shows that training label frequency does not strongly correlate with test error. Observe that several classes with a high error appear frequently in the training set. Indeed, the three classes with highest error – casette player, maillot, and water jug – all appear an equal number of times in the training set.
+
+# C.2 UNNORMALISED PLOTS ON IMAGENET
+
+Figure 8 presents plots of the unnormalised performance of the various methods compared in the body. Here, rather than subtract the performance of the baseline, we show the absolute accuracy of each method as the adversarial radius is varied. Evidently, the baseline and AGNOSTIC models tend to suffer in their validation error as the adversarial radius increases.
+
+# C.3 RESULTS ON CIFAR-100
+
+Figure 9 shows results on CIFAR-100, where we train various methods using a CIFAR-ResNet-18 as the underlying architecture, Here, we see a consistent and sizable improvement from ADVSHIFT over the baseline method. On this dataset, AGNOSTIC fares better, and eventually matches the performance of ADVSHIFT with a large adversarial radius. This is in keeping with the intended use-case of AGNOSTIC, i.e., minimising the worst-case loss. Figure 10 supplements these plots with unnormalised versions, to illustrate the absolute performance differences.
+
+![](images/0a7a04ccdfa5ecafabe929e79af042a313f6ca9119019b280e522edc085aa52f.jpg)  
+Figure 9: Comparison of performance of various methods on CIFAR-100.
+
+![](images/fec85174177b8c4435ef89c5a745fdb755c48cbee98c794a89b21e8bb1b3a962.jpg)  
+Figure 10: Comparison of performance of various methods on CIFAR-100 (unnormalised).
+
+We remark here that the choice of a CIFAR-ResNet-18 results in an underparameterised model, which does not perfectly fit the training data. In the overparameterised case, there are challenges with employing DRO, as noted by Sagawa et al. (2020). Addressing these challenges in settings where the training data is balanced remains an interesting open question.
+
+# D CONSTRAINED DRO DOES NOT PERMIT A BOLTZMAN SOLUTION
+
+We start with a simple example with three label classes $\{ a , b , c \}$ with class losses $l = \{ 1 , 2 , 4 \}$ respectively. We assume an uniform empirical distribution, i.e. $p _ { \mathrm { e m p } } = \{ 1 / 3 , 1 / 3 , 1 / \bar { 3 } \}$ . We consider two different problems. The first is to find the optimal solution to regularised objective,
+
+$$
+\begin{array} { r } { p = \mathrm { a r g m i n } _ { p } p ^ { \top } l + \gamma \mathrm { K L } ( p , p _ { \mathrm { e m p } } ) . } \end{array}
+$$
+
+This problem is well known (e.g. see 2.7.2 of lecture ) to permit a solution of form $p ( x ) \ =$ P exp lx/tx0∈{a,b,c} exp l0x/t for some t.
+
+In contrast, we show that distributions of the above form does not solve the constrained version of the problem. In particular, we consider the following optimisation problem:
+
+$$
+\operatorname* { m a x } _ { \boldsymbol { p } } p ^ { \intercal } l
+$$
+
+If the solution is of form $\begin{array} { r } { p ( x ) = \frac { \exp { l _ { x } / t } } { \sum _ { x ^ { \prime } \in \{ a , b , c \} } { \exp { l _ { x } ^ { \prime } / t } } } } \end{array}$ , then we know for ${ \mathit { l } } _ { b } \neq { \mathit { l } } _ { c }$
+
+$$
+( \log ( p _ { a } ) - \log ( p _ { c } ) ) / ( \log ( p _ { b } ) - \log ( p _ { c } ) ) = ( l _ { a } - l _ { c } ) / ( l _ { b } - l _ { c } ) .
+$$
+
+We solve the above problem with a convex optimizer using $r = 0 . 0 1$ and found $p _ { a } = 0 . 2 8 3 , p _ { b } =$ $0 . 3 2 2 , p _ { c } = 0 . 3 9 5$ .
+
+$$
+( \log ( p _ { a } ) - \log ( p _ { c } ) ) / ( \log ( p _ { b } ) - \log ( p _ { c } ) ) = 1 . 6 4 \neq ( l _ { a } - l _ { c } ) / ( l _ { b } - l _ { c } ) = 1 . 5 .
+$$
+
+Note that the above example shows that not all solutions of the contrained problem can be written a Boltzman distribution, i.e. $\begin{array} { r } { p ( x ) = \frac { \exp { l _ { x } / t } } { \sum _ { x ^ { \prime } \in \{ a , b , c \} } { \exp { l _ { x } ^ { \prime } / t } } } } \end{array}$ . Yet, this does not contradict with results
+
+[e.g. Lemma 4, Faury et al. (2020)] that claim there is a Boltzman distribution whose function value matches the optimal value of the constraint problem. Mathematically, we can have $p \neq p ^ { \prime }$ but $\mathbb { E } _ { p } [ l ( x ) ] = \mathbb { E } _ { p ^ { \prime } } [ l ( x ) ]$ .
+
+# E PROJECTING AN ADVERSARIAL DISTRIBUTION
+
+The projection operator in our setting aims to project a distribution $p$ into the set ${ \mathcal { P } } = \{ q : \mathrm { K L } ( q , { \hat { p } } ) \leq$ $r \}$ by solving the following problem:
+
+$$
+\begin{array} { c } { \displaystyle \operatorname* { m i n } _ { { q } } \| q - p \| ^ { 2 } } \\ { \displaystyle } \\ { \mathrm { s u c h ~ t h a t ~ } \sum _ { i } q _ { i } \log ( q _ { i } / p _ { i } ) \leq r } \\ { \displaystyle \sum _ { i } q _ { i } = 1 , } \\ { \forall i , q _ { i } \geq 0 , } \end{array}
+$$
+
+where $q _ { i } , p _ { i }$ denotes the $i _ { t h }$ component of $q , p$ and $n$ denotes number of classes. Given that our implementation is based on Tensorflow, we use the “trust-region constrained algorithm” provided by SciPy for easy integration with our python-based training procedure. However, even after extensive tuning, solving each problem up to $1 \%$ relative constraint error requires more than 1 minute when $n = 1 0 0 0$ (the number of labels in ImageNet). This means that if we train ResNet50 on ImageNet for $1 0 0 \mathrm { k }$ iterations, we need to spend $1 0 0 k$ minutes on projection operation, which is not affordable.
+
+# F PROOF OF PROPOSITION 1
+
+Proof. We only need to show that for large enough $\gamma _ { c }$ , any minimiser $p ^ { * }$ of the unconstrained problem satisfies that $\mathrm { K L } ( p ^ { * } , p _ { \mathrm { e m p } } ) \leq r$ . Since the distance from boundary of the simplex to any interior point is $+ \infty$ , we can safely assume that the point lies within the relative interior of the simplex. To prove the proposition, denote $c = \operatorname* { i n f } \{ | | { \hat { \nabla } } _ { p } \mathrm { K L } ( p , p _ { \mathrm { e m p } } ) | | \mid p \in \Delta ^ { L } , s . t . \mathrm { K L } ( p , p _ { \mathrm { e m p } } ) { \stackrel { . } { > } } r \} \quad$ By strict convexity of KL divergence and the fact that $r \ > \ 0$ , we know $c > 0$ . Denote the upper bound of loss as $M$ , then when $\gamma _ { c } > M / c$ , we know that $\mathrm { K L } ( p , p _ { \mathrm { e m p } } ) > r \implies 0 \notin$ $\partial _ { \pi } ( \mathbb { E } _ { \pi } [ \ell ( x , y , \theta ) ] + \operatorname* { m i n } \{ 0 , \gamma _ { c } ( r - \mathrm { K L } ( \pi , p _ { \mathrm { e m p } } ) ) \} )$ . However, since $p$ minimises the objective if and only if $0 \in \partial _ { \pi } ( \mathbb { E } _ { \pi } [ \ell ( x , y , \theta ) ] + \operatorname* { m i n } \{ 0 , \gamma _ { c } ( r - \mathrm { K L } ( \pi , p _ { \mathrm { e m p } } ) ) \} )$ , we have that any minimiser $p$ must satisfy $\mathrm { K L } ( \pi , p _ { \mathrm { e m p } } ) ) \leq r$ . □
+
+# G PROOF OF LEMMA 2
+
+Recall that we want to find $\pi _ { k + 1 }$ that minimises the following objective,
+
+$$
+\begin{array} { l } { \displaystyle \pi _ { k + 1 } = \underset { \pi \in \Delta } { \mathrm { a r g m i n } } h ( \pi ) + \frac { 1 } { 2 \lambda } ( \mathrm { K L } ( \pi , \pi _ { k } ) + 2 \lambda \langle g _ { k } , \pi \rangle ) } \\ { = \underset { \pi \in \Delta } { \mathrm { a r g m i n } } \operatorname* { m a x } \left\{ 0 , \frac { \alpha _ { c } } { 1 + \alpha _ { c } } \mathrm { K L } ( \pi , p _ { \mathrm { e m p } } ) \right\} + \frac { 1 } { 1 + \alpha _ { c } } ( \mathrm { K L } ( \pi , \pi _ { k } ) - \eta \langle g _ { k } , \pi \rangle ) , } \end{array}
+$$
+
+where $\eta = 1 / ( 2 \gamma _ { c } + 1 / \lambda )$ , $\alpha _ { c } = 2 \gamma _ { c } \lambda$ . Denote $v ( i )$ as the $i _ { t h }$ component of vector $v$ . Notice that the simplex can be written as a constraint that $\begin{array} { r } { \sum _ { i } \pi ( i ) = 1 ; \forall i , \pi ( i ) \ge 0 } \end{array}$ . Based on this constraint, we first write (6)’s Lagrangian dual
+
+$$
+\begin{array} { r } { L ( { a } , { b } , \pi ) = \displaystyle \sum _ { i } ( a _ { i } \pi ( i ) ) + b ( \displaystyle \sum _ { i } \pi ( i ) - 1 ) + \operatorname* { m a x } \left\{ 0 , \frac { \alpha _ { c } } { 1 + \alpha _ { c } } ( \mathrm { K L } ( \pi , p _ { \mathrm { e m p } } ) - r ) \right\} } \\ { + \frac { 1 } { 1 + \alpha _ { c } } ( \mathrm { K L } ( \pi , \pi _ { k } ) - \eta \langle { g } _ { k } , \pi \rangle ) } \end{array}
+$$
+
+where $\pi ( i )$ denotes the $i _ { t h }$ component of $\pi$ . If $\pi _ { k } > 0$ component-wise, then the optimal $\pi$ cannot lie on the boundary (i.e. $\forall i , \pi ( i ) > 0 \rangle$ , which results in $\mathrm { K L } ( \pi , \pi _ { k } ) = \infty$ . By Lagrangian duality and
+
+complementary slackness, we know that for if $\mathrm { K L } ( \pi , p _ { \mathrm { e m p } } ) > r$
+
+$$
+0 = { \frac { \partial } { \partial \pi ( i ) } } L ( a , b , \pi ) = b + { \frac { \alpha _ { c } } { 1 + \alpha _ { c } } } \log ( \pi ( i ) / p _ { \mathrm { e m p } } ( i ) ) + { \frac { 1 } { 1 + \alpha _ { c } } } \log ( \pi ( i ) / \pi _ { k } ( i ) ) - \eta g _ { k } ( i ) + 1 .
+$$
+
+On the other hand, if $\mathrm { K L } ( \pi , p _ { \mathrm { e m p } } ) < r$
+
+$$
+0 = \frac { \partial } { \partial \pi ( i ) } L ( a , b , \pi ) = b + \frac { 1 } { 1 + \alpha _ { c } } \log ( \pi ( i ) / \pi _ { k } ( i ) ) - \eta g _ { k } ( i ) + 1 .
+$$
+
+We discuss the case when $\mathrm { K L } ( \pi , p _ { \mathrm { e m p } } ) < r$ , and the other case follows similarly. Rearrange the optimality condition of Lagrangian multiplier, we get
+
+$$
+\frac { \alpha } { 1 + \alpha } \log ( \pi ( i ) / p _ { \mathrm { e m p } } ( i ) ) + \frac { 1 } { 1 + \alpha _ { c } } \log ( \pi ( i ) / \pi _ { k } ( i ) ) - \eta g _ { k } ( i ) = - b - 1 .
+$$
+
+Since $b$ is a constant for all coordinates,
+
+$$
+\begin{array} { r } { \pi ( i ) \propto ( p _ { \mathrm { e m p } } ( i ) _ { c } ^ { \alpha } \pi _ { k } ( i ) ) ^ { 1 / ( 1 + \alpha _ { c } ) } \exp { ( \frac { \eta g _ { k } ( i ) } { 1 + \alpha _ { c } } ) } . } \end{array}
+$$
+
+The result follows by noting that $\begin{array} { r } { \sum _ { i } \pi ( i ) = 1 } \end{array}$ .
+
+# H PROOF OF THEOREM 3
+
+For completeness, we define several terms used in optimisation. A function $f ( \theta )$ is $l$ −Lipschitz if for all $\theta , \theta ^ { \prime }$ ,
+
+$$
+\begin{array} { r } { | f ( \theta ) - f ( \theta ^ { \prime } ) | \leq l \| \theta - \theta ^ { \prime } \| . } \end{array}
+$$
+
+A function $f ( \theta )$ is $L$ −smooth if for all $\theta , \theta ^ { \prime }$ ,
+
+$$
+\| \nabla f ( \theta ) - \nabla f ( \theta ^ { \prime } ) \| \leq L \| \theta - \theta ^ { \prime } \| .
+$$
+
+A function $f ( \theta )$ is $L -$ weakly convex if $\begin{array} { r } { f ( \theta ) + \frac { L } { 2 } \lVert \theta \rVert ^ { 2 } } \end{array}$ is convex.
+
+Then we can state the formal theorem below.
+
+Theorem 4 (formal version of Theorem 3). Under Assumptions 1–4, the update in (8) generates a sequence of points $\theta _ { 1 } , . . . , \theta _ { T }$ with the following property:
+
+$$
+\begin{array} { r l } & { \frac { 1 } { T } \displaystyle \sum _ { t } \mathbb { E } [ \| \nabla F _ { 1 / 2 L } ( \theta _ { t } ) \| ^ { 2 } ] \leq \frac { 1 } { T ^ { 1 / 4 } } \left( \frac { 2 } { L } ( F _ { 1 / 2 L } ( \theta _ { 0 } ) - F _ { 1 / 2 L } ^ { \ast } ) + 2 G + G ^ { 2 } + \frac { R } { 2 } + ( l ^ { 2 } + \sigma ^ { 2 } ) ^ { 1 / 2 } ) \right) } \\ & { \quad \quad \quad \quad \quad + ( h ^ { \ast } - h ( \pi _ { 0 } ) ) / T } \end{array}
+$$
+
+Proof. For convenience, denote $\Phi ( \theta , \pi ) = f ( \theta , \pi ) + h ( \pi ) , F ( \theta ) = \mathrm { m a x } _ { p } \Phi ( \theta , p )$ . We start by following the standard SGD proof. Denote $g _ { \theta }$ as the stochastic gradient evaluated at step $t - 1$ with respect to $\theta$ . Denote $\begin{array} { r } { \hat { \theta } = \mathrm { p r o x } _ { F / 2 L } ( \theta ) : = \arg \operatorname* { m i n } _ { w } \{ F ( w ) + 2 L \| w - \theta \| ^ { 2 } \} . } \end{array}$ . Conditioned on $\theta _ { t - 1 }$ , we have
+
+$$
+\begin{array} { r l } & { \mathbb { E } [ \| \hat { \theta } _ { t - 1 } - \theta _ { t } \| ^ { 2 } ] = \| \theta _ { t - 1 } - \hat { \theta } _ { t - 1 } \| ^ { 2 } + 2 \eta _ { \theta } \mathbb { E } [ \langle \hat { \theta } _ { t - 1 } - \theta _ { t - 1 } , g _ { \theta } \rangle ] + \eta _ { \theta } ^ { 2 } \mathbb { E } [ \| g _ { \theta } \| ^ { 2 } ] } \\ & { \qquad \leq \| \theta _ { t - 1 } - \hat { \theta } _ { t - 1 } \| ^ { 2 } + 2 \eta _ { \theta } \langle \hat { \theta } _ { t - 1 } - \theta _ { t - 1 } , \nabla _ { \theta } \Phi ( \theta _ { t - 1 } , \pi _ { t - 1 } ) \rangle + \eta _ { \theta } ^ { 2 } ( L ^ { 2 } + \sigma ^ { 2 } ) } \end{array}
+$$
+
+where the first equality follows by $\theta _ { t } = \theta _ { t - 1 } - \eta _ { \theta } \nabla _ { \theta } \Phi ( \theta _ { t - 1 } , \pi _ { t - 1 } )$ . Next, we observe that
+
+$$
+\begin{array} { r l r } {  { \langle \hat { \theta } _ { t - 1 } - \theta _ { t - 1 } , \nabla _ { \theta } \Phi ( \theta _ { t - 1 } , \pi _ { t - 1 } ) \rangle \leq \Phi ( \hat { \theta } _ { t - 1 } , \pi _ { t - 1 } ) - \Phi ( \theta _ { t - 1 } , \pi _ { t - 1 } ) + \frac { L } { 2 } \| \hat { \theta } _ { t - 1 } - \theta _ { t - 1 } \| ^ { 2 } } } \\ & { } & \\ & { } & { \leq F ( \hat { \theta } _ { t - 1 } ) - \Phi ( \theta _ { t - 1 } , \pi _ { t - 1 } ) + \displaystyle \frac { L } { 2 } \| \hat { \theta } _ { t - 1 } - \theta _ { t - 1 } \| ^ { 2 } } \\ & { } & \\ & { } & { \leq F ( \theta _ { t - 1 } ) - \Phi ( \theta _ { t - 1 } , \pi _ { t - 1 } ) - \displaystyle \frac { L } { 2 } \| \hat { \theta } _ { t - 1 } - \theta _ { t - 1 } \| ^ { 2 } } \end{array}
+$$
+
+The first line follows by convexity and $L -$ smoothness. The second line by definition of $F$ . The third line by definition of $\hat { \theta }$ . Next, by definition of Moreau envelop,
+
+$$
+F _ { 1 / 2 L } ( \theta _ { t } ) \leq F ( \hat { \theta } _ { t - 1 } ) + L \Vert \hat { \theta } _ { t - 1 } - \theta _ { t } \Vert ^ { 2 }
+$$
+
+Take expectation on both sides and we get
+
+$$
+\begin{array} { r l } & { \cdots _ { \ell } \binom { n - 1 } { \ell - 1 } + \mathcal { L } [ L \| \hat { \theta } _ { t - 1 } - \theta _ { t } \| ^ { 2 } ] } \\ & { \leq F ( \hat { \theta } _ { t - 1 } ) + \mathbb { E } [ L \| \hat { \theta } _ { t - 1 } - \theta _ { t } \| ^ { 2 } ] } \\ & { = F ( \hat { \theta } _ { t - 1 } ) + L ( \| \theta _ { t - 1 } - \hat { \theta } _ { t - 1 } \| ^ { 2 } + 2 \eta _ { \theta } \langle \hat { \theta } _ { t - 1 } - \theta _ { t - 1 } , \nabla _ { \theta } \Phi ( \theta _ { t - 1 } , \pi _ { t - 1 } ) \rangle + \eta _ { \theta } ^ { 2 } ( l ^ { 2 } + \sigma ^ { 2 } ) ) } \\ & { \leq F _ { 1 / 2 L } ( \theta _ { t - 1 } ) + 2 L \eta _ { \theta } ( \Phi ( \hat { \theta } _ { t - 1 } , \pi _ { t - 1 } ) - \Phi ( \theta _ { t - 1 } , \pi _ { t - 1 } ) - \displaystyle \frac { L } { 2 } \| \hat { \theta } _ { t - 1 } - \theta _ { t - 1 } \| ^ { 2 } ) + L \eta _ { \theta } ^ { 2 } ( l ^ { 2 } + \sigma ^ { 2 } ) } \end{array}
+$$
+
+The second line substitutes in (9). The third line follows by convexity and $L -$ smoothness. Denote that $\Delta _ { t } : = F ( \hat { \theta } _ { t - 1 } ) - \Phi ( \theta _ { t - 1 } , \pi _ { t - 1 } ) \geq \Phi ( \hat { \theta } _ { t - 1 } , \pi _ { t - 1 } ) - \Phi ( \theta _ { t - 1 } , \pi _ { t - 1 } )$ . We can sum over $t$ and take expectation recursively to get,
+
+$$
+\begin{array} { r l r } {  { \sum _ { t } \mathbb { E } [ \| \nabla F _ { 1 / 2 L } ( \theta _ { t } ) \| ^ { 2 } ] = 2 L \sum _ { t } \mathbb { E } [ \| \hat { \theta } _ { t - 1 } - \theta _ { t - 1 } \| ^ { 2 } ] } } \\ & { } & { \leq \frac { 2 } { L \eta _ { \theta } } ( F _ { 1 / 2 L } ( \theta _ { 0 } ) - F _ { 1 / 2 L } ^ { * } ) + 4 \sum _ { t } \Delta _ { t } + T \eta _ { \theta } ( l ^ { 2 } + \sigma ^ { 2 } ) ) } \end{array}
+$$
+
+where $F _ { 1 / 2 L } ^ { * } = \operatorname* { m i n } _ { \theta } F _ { 1 / 2 L } ( \theta )$ . The first equality follows by the definition of Moreau envelope. The second inequality follows by rearranging (11).
+
+Next, we aim to bound the accumulated error $\textstyle \sum _ { t } \Delta _ { t }$ .
+
+Recall that the update for the $\pi$ is as follows for $\mathbb { E } [ g _ { \pi } ] = \nabla _ { \pi } f ( \theta , \pi )$ ,
+
+$$
+\begin{array} { r } { \pi _ { k + 1 } : = \operatorname * { a r g m i n } _ { \pi \in \Delta ^ { L } } \{ - 2 \lambda \langle g _ { \pi } , \pi \rangle - 2 \lambda h ( \pi ) + \mathrm { K L } ( \pi , \pi _ { k } ) \} } \end{array}
+$$
+
+Applying Lemma 5 with ${ \cal L } ( \pi ) = - 2 \lambda \langle g _ { \pi } , \pi \rangle + - 2 \lambda h ( \pi )$ , we get
+
+$$
+\begin{array} { r l } & { - h ( \pi ^ { * } ( \theta _ { s } ) ) - \langle g _ { \pi } , \pi ^ { * } ( \theta _ { s } ) \rangle + \mathrm { K L } ( \pi ^ { * } , \pi _ { k } ) } \\ & { \qquad \ge - \langle g _ { \pi } , \pi _ { k + 1 } \rangle - h ( \pi _ { k + 1 } ) + \mathrm { K L } ( \pi _ { k + 1 } , \pi _ { k } ) + \mathrm { K L } ( \pi ^ { * } , \pi _ { k + 1 } ) } \end{array}
+$$
+
+Rearrange and take expectation we get
+
+$$
+\begin{array} { r l } & { 2 \lambda ( \mathbb { E } [ \langle - g _ { \pi } , \pi _ { k } - \pi ^ { * } ( \theta _ { s } ) \rangle ] - \mathbb { E } [ h ( \pi _ { k + 1 } ) ] + \mathbb { E } [ h ( \pi ^ { * } ( \theta _ { s } ) ) ] ) } \\ & { \ \leq - \mathbb { E } [ \mathrm { K L } ( \pi _ { k + 1 } , \pi _ { k } ) ] + \mathrm { K L } ( \pi ^ { * } , \pi _ { k + 1 } ) - \mathrm { K L } ( \pi ^ { * } , \pi _ { k } ) + 2 \lambda ( \mathbb { E } [ \langle g _ { \pi } , \pi _ { k } - \pi _ { k + 1 } \rangle ] ) } \\ & { \ \leq - \mathbb { E } [ \mathrm { K L } ( \pi _ { k } , \pi ^ { * } ) ] + \mathbb { E } [ \mathrm { K L } ( \pi ^ { * } , \pi _ { k + 1 } ) ] - \| \pi ^ { * } - \pi _ { k } \| _ { 1 } ^ { 2 } / 2 + 2 \lambda ^ { 2 } \mathbb { E } [ \| g _ { \pi } \| _ { \infty } ^ { 2 } ] + \| \pi ^ { * } - \pi _ { k } \| _ { 1 } ^ { 2 } / 2 } \end{array}
+$$
+
+The second inequality follows by the fact that $K L -$ divergence is strongly convex with respect to $L _ { 1 }$ norm and Cauchy-Schwartz inequality. We further observe that
+
+$$
+\begin{array} { r l } & { - \mathbb { E } [ \langle g _ { \pi } , \pi _ { k } - \pi ^ { * } ( \theta _ { s } ) \rangle ] = - \langle \nabla _ { \pi } f ( \theta _ { k } , \pi _ { k } ) , \pi _ { k } - \pi ^ { * } ( \theta _ { s } ) \rangle \geq - f ( \theta _ { k } , \pi _ { k } ) + f ( \theta _ { k } , \pi ^ { * } ( \theta _ { s } ) ) } \\ & { \quad \quad \quad \quad = - f ( \theta _ { k } , \pi _ { k } ) + f ( \theta _ { k } , \pi ^ { * } ( \theta _ { k } ) ) - f ( \theta _ { k } , \pi ^ { * } ( \theta _ { k } ) ) + f ( \theta _ { k } , \pi ^ { * } ( \theta _ { s } ) ) } \\ & { \quad \quad \quad \geq - f ( \theta _ { k } , \pi _ { k } ) + f ( \theta _ { k } , \pi ^ { * } ( \theta _ { k } ) ) - f ( \theta _ { k } , \pi ^ { * } ( \theta _ { k } ) ) + f ( \theta _ { s } , \pi ^ { * } ( \theta _ { k } ) ) } \\ & { \quad \quad \quad - f ( \theta _ { s } , \pi ^ { * } ( \theta _ { s } ) ) + f ( \theta _ { k } , \pi ^ { * } ( \theta _ { s } ) ) } \\ & { \quad \quad \quad \geq - f ( \theta _ { k } , \pi _ { k } ) + f ( \theta _ { k } , \pi ^ { * } ( \theta _ { k } ) ) - 2 l \| \theta _ { s } - \theta _ { k } \| } \end{array}
+$$
+
+The first inequality follows by concavity. The third line follows by $f ( \theta _ { s } , \pi ^ { * } ( \theta _ { k } ) ) \leq f ( \theta _ { s } , \pi ^ { * } ( \theta _ { s } ) )$ The last inequality follows by Lipschitzness. Similarly,
+
+$$
+- h ( \theta _ { k } , \pi _ { k } ) + h ( \theta _ { k } , \pi ^ { * } ( \theta _ { s } ) ) \geq - h ( \theta _ { k } , \pi _ { k } ) + h ( \theta _ { k } , \pi ^ { * } ( \theta _ { k } ) ) - 2 l \| \theta _ { s } - \theta _ { k } \|
+$$
+
+We can take iterative expectation and get sum over $k = s + 1 , . . . , s + B$ to get
+
+$$
+\begin{array} { r l r } {  { \sum _ { k = s + 1 } ^ { s + B } \mathbb { E } [ - f ( \theta _ { k } , \pi _ { k } ) + f ( \theta _ { k } , \pi ^ { * } ( \theta _ { k } ) ) - h ( \pi _ { k } ) + h ( \pi ^ { * } ( \theta _ { k } ) ) ] } } \\ & { } & \\ & { } & { \leq - h ( \pi _ { s } ) + \mathbb { E } [ h ( \pi _ { s + B } ) ] + 4 l \sum _ { k = s + 1 } ^ { s + B } \sum _ { j = s } ^ { k } \mathbb { E } [ \| \theta _ { j } - \theta _ { j + 1 } \| ] + \lambda B G ^ { 2 } } \\ & { } & \\ & { } & { \quad + \frac { 1 } { 2 \lambda } ( \mathbb { E } [ \mathrm { K L } ( \pi ^ { * } ( \theta _ { s } ) , \pi _ { 0 } ) ] - \mathbb { E } [ \mathrm { K L } ( \pi ^ { * } ( \theta _ { s } ) , \pi _ { s } ) ] ) } \end{array}
+$$
+
+Note that $\Delta _ { k } = - f ( \theta _ { k } , \pi _ { k } ) + f ( \theta _ { k } , \pi ^ { * } ( \theta _ { k } ) ) - h ( \pi _ { k } ) + h ( \pi ^ { * } ( \theta _ { k } ) )$ , hence
+
+$$
+\begin{array} { r l r } {  { \sum _ { k = s + 1 } ^ { s + B } \mathbb { E } [ \Delta _ { k } ] \le - h ( \pi _ { s } ) + \mathbb { E } [ h ( \pi _ { s + B } ) ] + 2 \eta _ { \theta } l B ^ { 2 } G + \lambda B G ^ { 2 } } } \\ & { } & { \quad + \displaystyle \frac { 1 } { 2 \lambda } ( \mathbb { E } [ { \mathrm { K L } } ( \pi ^ { \ast } ( \theta _ { s } ) , \pi _ { 0 } ) ] - \mathbb { E } [ { \mathrm { K L } } ( \pi ^ { \ast } ( \theta _ { s } ) , \pi _ { s } ) ] ) } \end{array}
+$$
+
+By further sum over all blocks and divide by total number of iterations $T$ , we get
+
+$$
+\begin{array} { r l r } {  { \frac { 1 } { T } \sum _ { b = 1 } ^ { T / B } \sum _ { k = b s + 1 } ^ { s + B } \mathbb { E } [ \Delta _ { k } ] \le ( - h ( \pi _ { 0 } ) + \mathbb { E } [ h ( \pi _ { T } ) ] ) / T + 2 \eta _ { \theta } B G + \lambda G ^ { 2 } } } \\ & { } & { \quad \quad + \frac { 1 } { 2 \lambda B } ( \mathbb { E } [ \mathrm { K L } ( \pi ^ { * } ( \theta _ { s } ) , \pi _ { 0 } ) ] - \mathbb { E } [ \mathrm { K L } ( \pi ^ { * } ( \theta _ { s } ) , \pi _ { s } ) ] ) } \end{array}
+$$
+
+Substitute the above inequality into (12) and we get
+
+$$
+\begin{array} { r l } { \displaystyle \frac { 1 } { T } \sum _ { t } \mathbb { E } [ \| \nabla F _ { 1 / 2 L } ( \theta _ { t } ) \| ^ { 2 } ] \leq \frac { 2 } { T L \eta _ { \theta } } ( F _ { 1 / 2 L } ( \theta _ { 0 } ) - F _ { 1 / 2 L } ^ { \ast } ) + 4 ( - h ( \pi _ { 0 } ) + \mathbb { E } [ h ( \pi _ { T } ) ] ) / T + 2 \eta _ { \theta } B G + \lambda G } & { } \\ { + \displaystyle \frac { 1 } { 2 \lambda B } ( \mathbb { E } [ \mathrm { K L } ( \pi ^ { \ast } ( \theta _ { s } ) , \pi _ { 0 } ) ] - \mathbb { E } [ \mathrm { K L } ( \pi ^ { \ast } ( \theta _ { T } ) , \pi _ { T } ) ] ) + \eta _ { \theta } ( l ^ { 2 } + \sigma ^ { 2 } ) ^ { 1 / 2 } ) } & { } \end{array}
+$$
+
+If we set $\eta _ { \theta } = T ^ { - 3 / 4 } , B = T ^ { 1 / 2 } , \lambda = T ^ { - 1 / 4 }$ , then we see that
+
+$$
+\begin{array} { l } { \displaystyle \frac { 1 } { T } \sum _ { t } \mathbb { E } [ \| \nabla F _ { 1 / 2 L } ( \theta _ { t } ) \| ^ { 2 } ] \leq \frac { 1 } { T ^ { 1 / 4 } } \left( \frac { 2 } { L } ( F _ { 1 / 2 L } ( \theta _ { 0 } ) - F _ { 1 / 2 L } ^ { \ast } ) + 2 G + G ^ { 2 } + \frac { R } { 2 } + ( l ^ { 2 } + \sigma ^ { 2 } ) ^ { 1 / 2 } ) \right) } \\ { \displaystyle \qquad + ( - h ( \pi _ { 0 } ) + h ^ { \ast } ) / T } \end{array}
+$$
+
+Lemma 5. For any differentiable convex function $\begin{array} { r } { L , i f x ^ { * } = \operatorname * { a r g m i n } _ { x \in \Delta } \{ L ( x ) + \operatorname { K L } ( x , x _ { 0 } ) \} } \end{array}$ , then for any $x ^ { \prime } \in \Delta$ , we have
+
+$$
+\ell ( x ^ { \prime } ) + \mathrm { K L } ( x ^ { \prime } , x _ { 0 } ) \geq \ell ( x ^ { * } ) + \mathrm { K L } ( x ^ { * } , x _ { 0 } ) + \mathrm { K L } ( x ^ { \prime } , x ^ { * } ) .
+$$
+
+Proof. This Lemma is well-known, but we include a proof for completeness. By optimality of $x ^ { * }$ and convexity of $\Delta$ , we know that
+
+$$
+\langle \nabla \ell ( x ^ { * } ) + \nabla \phi ( x ^ { * } ) - \nabla \phi ( x _ { 0 } ) , x - x ^ { * } \rangle \geq 0 ,
+$$
+
+where $\begin{array} { r } { \phi ( x ) = \sum _ { i } x _ { i } \log ( x _ { i } ) } \end{array}$ , and the Bregman divergence defined according to $\phi$ is KL-divergence. Then
+
+$$
+\begin{array} { r l } & { \ell ( x ^ { \prime } ) \geq \ell ( x ^ { * } ) + \langle \nabla \ell ( x ^ { * } ) , x ^ { \prime } - x ^ { * } \rangle } \\ & { \qquad \geq \ell ( x ^ { * } ) + \langle \nabla \phi ( x _ { 0 } ) - \nabla \phi ( x ^ { * } ) , x - x ^ { * } \rangle } \\ & { = \ell ( x ^ { * } ) - \langle \nabla \phi ( x _ { 0 } ) , x ^ { * } - x _ { 0 } \rangle + \phi ( x ^ { * } ) - \phi ( x _ { 0 } ) } \\ & { \qquad + \left. \nabla \phi ( x _ { 0 } ) , x ^ { \prime } - x _ { 0 } \right. + \phi ( x ^ { \prime } ) - \phi ( x _ { 0 } ) - \langle \nabla \phi ( x ^ { * } ) , x ^ { \prime } - x ^ { * } \rangle + \phi ( x ^ { \prime } ) - \phi ( x ^ { * } ) } \\ & { = \ell ( x ^ { * } ) + \mathrm { K L } ( x ^ { * } , x _ { 0 } ) - \mathrm { K L } ( x ^ { \prime } , x _ { 0 } ) + \mathrm { K L } ( x ^ { \prime } , x ^ { * } ) } \end{array}
+$$

parse/train/Drynvt7gg4L/Drynvt7gg4L.md

@@ -0,0 +1,206 @@
+# ADASPEECH: ADAPTIVE TEXT TO SPEECH FOR CUSTOM VOICE
+
+Mingjian Chen∗, Xu Tan∗, Bohan Li, Yanqing Liu, Tao Qin, Sheng Zhao, Tie-Yan Liu   
+Microsoft Research Asia, Microsoft Azure Speech   
+{xuta,taoqin,szhao,tyliu}@microsoft.com
+
+# ABSTRACT
+
+Custom voice, a specific text to speech (TTS) service in commercial speech platforms, aims to adapt a source TTS model to synthesize personal voice for a target speaker using few speech from her/him. Custom voice presents two unique challenges for TTS adaptation: 1) to support diverse customers, the adaptation model needs to handle diverse acoustic conditions which could be very different from source speech data, and 2) to support a large number of customers, the adaptation parameters need to be small enough for each target speaker to reduce memory usage while maintaining high voice quality. In this work, we propose AdaSpeech, an adaptive TTS system for high-quality and efficient customization of new voices. We design several techniques in AdaSpeech to address the two challenges in custom voice: 1) To handle different acoustic conditions, we model the acoustic information in both utterance and phoneme level. Specifically, we use one acoustic encoder to extract an utterance-level vector and another one to extract a sequence of phoneme-level vectors from the target speech during pre-training and fine-tuning; in inference, we extract the utterance-level vector from a reference speech and use an acoustic predictor to predict the phonemelevel vectors. 2) To better trade off the adaptation parameters and voice quality, we introduce conditional layer normalization in the mel-spectrogram decoder of AdaSpeech, and fine-tune this part in addition to speaker embedding for adaptation. We pre-train the source TTS model on LibriTTS datasets and fine-tune it on VCTK and LJSpeech datasets (with different acoustic conditions from LibriTTS) with few adaptation data, e.g., 20 sentences, about 1 minute speech. Experiment results show that AdaSpeech achieves much better adaptation quality than baseline methods, with only about 5K specific parameters for each speaker, which demonstrates its effectiveness for custom voice. The audio samples are available at https://speechresearch.github.io/adaspeech/.
+
+# 1 INTRODUCTION
+
+Text to speech (TTS) aims to synthesize natural and intelligible voice from text, and attracts a lot of interests in machine learning community (Arik et al., 2017; Wang et al., 2017; Gibiansky et al., 2017; Ping et al., 2018; Shen et al., 2018; Ren et al., 2019). TTS models can synthesize natural human voice when training with a large amount of high-quality and single-speaker recordings (Ito, 2017), and has been extended to multi-speaker scenarios (Gibiansky et al., 2017; Ping et al., 2018; Zen et al., 2019; Chen et al., 2020) using multi-speaker corpora (Panayotov et al., 2015; Veaux et al., 2016; Zen et al., 2019). However, these corpora contain a fixed set of speakers where each speaker still has a certain amount of speech data.
+
+Nowadays, custom voice has attracted increasing interests in different application scenarios such as personal assistant, news broadcast and audio navigation, and has been widely supported in commercial speech platforms (some custom voice services include Microsoft Azure, Amazon AWS and Google Cloud). In custom voice, a source TTS model is usually adapted on personalized voices with few adaptation data, since the users of custom voice prefer to record as few adaptation data as possible (several minutes or seconds) for convenient purpose. Few adaptation data presents great challenges on the naturalness and similarity of adapted voice. Furthermore, there are also several distinctive challenges in custom voice: 1) The recordings of the custom users are usually of different acoustic conditions from the source speech data (the data to train the source TTS model). For example, the adaptation data is usually recorded with diverse speaking prosodies, styles, emotions, accents and recording environments. The mismatch in these acoustic conditions makes the source model difficult to generalize and leads to poor adaptation quality. 2) When adapting the source TTS model to a new voice, there is a trade-off between the fine-tuning parameters and voice quality. Generally speaking, more adaptation parameters will usually result in better voice quality, which, as a result, increases the memory storage and serving cost1.
+
+While previous works in TTS adaptation have well considered the few adaptation data setting in custom voice, they have not fully addressed the above challenges. They fine-tune the whole model (Chen et al., 2018; Kons et al., 2019) or decoder part (Moss et al., 2020; Zhang et al., 2020), achieving good quality but causing too many adaptation parameters. Reducing the amount of adaptation parameters is necessary for the deployment of commercialized custom voice. Otherwise, the memory storage would explode as the increase of users. Some works only fine-tune the speaker embedding (Arik et al., 2018; Chen et al., 2018), or train a speaker encoder module (Arik et al., 2018; Jia et al., 2018; Cooper et al., 2020; Li et al., 2017; Wan et al., 2018) that does not need fine-tuning during adaptation. While these approaches lead a light-weight and efficient adaptation, they result in poor adaptation quality. Moreover, most previous works assume the source speech data and adaptation data are in the same domain and do not consider the setting with different acoustic conditions, which is not practical in custom voice scenarios.
+
+In this paper, we propose AdaSpeech, an adaptive TTS model for high-quality and efficient customization of new voice. AdaSpeech employ a three-stage pipeline for custom voice: 1) pre-training; 2) fine-tuning; 3) inference. During the pre-training stage, the TTS model is trained on large-scale multi-speaker datasets, which can ensure the TTS model to cover diverse text and speaking voices that is helpful for adaptation. During the fine-tuning stage, the source TTS model is adapted on a new voice by fine-tuning (a part of) the model parameters on the limited adaptation data with diverse acoustic conditions. During the inference stage, both the unadapted part (parameters shared by all custom voices) and the adapted part (each custom voice has specific adapted parameters) of the TTS model are used for the inference request. We build AdaSpeech based on the popular non-autoregressive TTS models (Ren et al., 2019; Peng et al., 2020; Kim et al., 2020; Ren et al., 2021) and further design several techniques to address the challenges in custom voice:
+
+• Acoustic condition modeling. In order to handle different acoustic conditions for adaptation, we model the acoustic conditions in both utterance and phoneme level in pre-training and fine-tuning. Specifically, we use two acoustic encoders to extract an utterance-level vector and a sequence of phoneme-level vectors from the target speech, which are taken as the input of the mel-spectrogram decoder to represent the global and local acoustic conditions respectively. In this way, the decoder can predict speech in different acoustic conditions based on these acoustic information. Otherwise, the model would memorize the acoustic conditions and cannot generalize well. In inference, we extract the utterance-level vector from a reference speech and use another acoustic predictor that is built upon the phoneme encoder to predict the phoneme-level vectors.
+
+• Conditional layer normalization. To fine-tune as small amount of parameters as possible while ensuring the adaptation quality, we modify the layer normalization (Ba et al., 2016) in the melspectrogram decoder in pre-training, by using speaker embedding as the conditional information to generate the scale and bias vector in layer normalization. In fine-tuning, we only adapt the parameters related to the conditional layer normalization. In this way, we can greatly reduce adaptation parameters and thus memory storage2 compared with fine-tuning the whole model, but maintain high-quality adaptation voice thanks to the flexibility of conditional layer normalization.
+
+To evaluate the effectiveness of our proposed AdaSpeech for custom voice, we conduct experiments to train the TTS model on LibriTTS datasets and adapt the model on VCTK and LJSpeech datasets with different adaptation settings. Experiment results show that AdaSpeech achieves better adaptation quality in terms of MOS (mean opinion score) and SMOS (similarity MOS) than baseline methods, with
+
+only about 5K specific parameters for each speaker, demonstrating its effectiveness for custom voice.   
+Audio samples are available at https://speechresearch.github.io/adaspeech/.
+
+# 2 ADASPEECH
+
+In this section, we first describe the overall design of our proposed AdaSpeech, and then introduce the key techniques to address the challenges in custom voice. At last, we list the pre-training, finetuning and inference pipeline of AdaSpeech for custom voice.
+
+The model structure of AdaSpeech is shown in Figure 1. We adopt FastSpeech 2 (Ren et al., 2021) as the model backbone considering the FastSpeech (Ren et al., 2019; 2021) series are one of the most popular models in non-autoregressive TTS. The basic model backbone consists of a phoneme encoder, a mel-spectrogram decoder, and a variance adaptor which provides variance information including duration, pitch and energy into the phoneme hidden sequence following Ren et al. (2021). As shown in Figure 1, we design two additional components to address the distinctive challenges in custom voice: 1) to support diverse customers, we use acoustic condition modeling to capture the diverse acoustic conditions of adaptation speech in different granularities; 2) to support a large number of customers with affordable memory storage, we use conditional layer normalization in decoder for efficient adaptation with few parameters while high voice quality. In the next subsections, we introduce the details of these components respectively.
+
+# 2.1 ACOUSTIC CONDITION MODELING
+
+In custom voice, the adaptation data can be spoken with diverse prosodies, styles, accents, and can be recorded under various environments, which can make the acoustic conditions far different from that in source speech data. This presents great challenges to adapt the source TTS model, since the source speech cannot cover all the acoustic conditions in custom voice. A practical way to alleviate this issue is to improve the adaptability (generalizability) of source TTS model. In text to speech, since the input text lacks enough acoustic conditions (such as speaker timbre, prosody and recording environments) to predict the target speech, the model tends to memorize and overfit on the training data (Ren et al., 2021), and has poor generalization during adaptation. A natural way to solve such problem is to provide corresponding acoustic conditions as input to make the model learn reasonable text-to-speech mapping towards better generalization instead of memorizing.
+
+![](images/b16230a0b3471c9cf7166d42bf87e2d4d83fb2c8fad20fc0c5c9c58c2c644de2.jpg)  
+Figure 1: AdaSpeech.
+
+To better model the acoustic conditions with different granularities, we categorize the acoustic conditions in different levels as shown in Figure 2a: 1) speaker level, the coarse-grained acoustic conditions to capture the overall characteristics of a speaker; 2) utterance level, the fine-grained acoustic conditions in each utterance of a speaker; 3) phoneme level, the more fine-grained acoustic conditions in each phoneme of an utterance, such as accents on specific phonemes, pitches, prosodies and temporal environment noises3. Since speaker ID (embedding) is widely used to capture speakerlevel acoustic conditions in multi-speaker scenario (Chen et al., 2020), speaker embedding is used by default. We describe the utterance-level and phoneme-level acoustic condition modeling as follows.
+
+• Utterance Level. We use an acoustic encoder to extract a vector from a reference speech, similar to Arik et al. (2018); Jia et al. (2018); Cooper et al. (2020), and then expand and add it to the phoneme hidden sequence to provide the utterance-level acoustic conditions. As shown in Figure 2b, the acoustic encoder consists of several convolutional layers and a mean pooling layer to get a single vector. The reference speech is the target speech during training, while a randomly chosen speech of this speaker during inference.
+
+• Phoneme Level. We use another acoustic encoder (shown in Figure 2c) to extract a sequence of phoneme-level vectors from the target speech and add it to the phoneme hidden sequence to provide the phoneme-level acoustic conditions4. In order to extract phoneme-level information from speech, we first average the speech frames corresponding to the same phoneme according to alignment between phoneme and mel-spectrogram sequence (shown in Figure 2a), to convert to length of speech frame sequence into the length of phoneme sequence, similar to Sun et al. (2020); Zeng et al. (2020). During inference, we use another phoneme-level acoustic predictor (shown in Figure 2d) which is built upon the original phoneme encoder to predict the phoneme-level vectors.
+
+![](images/1b8115e8378ff3f0bce5e8c218cc53e46a1027bcc95a6b54cc7689458e994c80.jpg)  
+Figure 2: (a) The overall structure of acoustic condition modeling. (b) Utterance-level acoustic encoder. (c) Phoneme-level acoustic encoder, where phoneme-level mel means the mel-frames aligned to the same phoneme are averaged. (d) Phoneme-level acoustic predictor, where phoneme hiddens is the hidden sequence from the phoneme encoder in Figure 1. ‘Conv1D $( m , n ) $ means the kernel size and stride size in 1D convolution is $m$ and $n$ respectively. ‘LN’ means layer normalization. As shown in Figure 2a, the phoneme-level vectors are directly added element-wisely into the hidden sequence, and the utterance-level and speaker level vector/embedding are first expanded to the same length and then added element-wisely into the hidden sequence.
+
+Using speech encoders to extract a single vector or a sequence of vectors to represent the characteristics of a speech sequence has been adopted in previous works (Arik et al., 2018; Jia et al., 2018; Cooper et al., 2020; Sun et al., 2020; Zeng et al., 2020). They usually leverage them to improve the speaker timbre or prosody of the TTS model, or improve the controllability of the model. The key contribution in our acoustic condition modeling in this work is the novel perspective to model the diverse acoustic conditions in different granularities to make the source model more adaptable to different adaptation data. As analyzed in Section 4.2, utterance-level and phoneme-level acoustic modeling can indeed help the learning of acoustic conditions and is critical to ensure the adaptation quality.
+
+# 2.2 CONDITIONAL LAYER NORMALIZATION
+
+Achieving high adaptation quality while using small adaptation parameters is challenging. Previous works use zero-shot adaptation with speaker encoder (Arik et al., 2018; Jia et al., 2018; Cooper et al., 2020) or only fine-tune the speaker embedding cannot achieve satisfied quality. Can we greatly increase the voice quality at the cost of slightly more but negligible parameters? To this end, we analyze the model parameters of FastSpeech 2 (Ren et al., 2021), which is basically built upon the structure of Transformer (Vaswani et al., 2017), with a self-attention network and a feed-forward network in each Transformer block. Both the matrix multiplications in the query, key, value and output of self-attention and two-layer feed-forward networks are parameter-intensive, which is not efficient to adapt. We find that layer normalization (Ba et al., 2016) is adopted in each self-attention and feed-forward network in decoder, which can greatly influence the hidden activation and final prediction with a light-weight learnable scale vector $\gamma$ and bias vector $\beta$ : $\begin{array} { r } { L N ( x ) = \gamma \frac { x - \mu } { \sigma } + \beta } \end{array}$ , where $\mu$ and $\sigma$ are the mean and variance of hidden vector $x$ .
+
+![](images/a66e8ffc76fa99ca95e58f3c7f706be919dbfefddd07a11631defff56ae26599.jpg)  
+Figure 3: Conditional LayerNorm.
+
+If we can determine the scale and bias vector in layer normalization with the corresponding speaker characteristics using a small conditional network, then we can fine-tune this conditional network when adapting to a new voice, and greatly reduce the adaptation parameters while ensuring the adaptation quality. As shown in Figure 3, the conditional network consists of two simple linear layers $W _ { c } ^ { \gamma }$ and $\hat W _ { c } ^ { \beta }$ that take speaker embedding $E ^ { s }$ as input and output the scale and bias vector respectively:
+
+$$
+\gamma _ { c } ^ { s } = E ^ { s } * W _ { c } ^ { \gamma } , \beta _ { c } ^ { s } = E ^ { s } * W _ { c } ^ { \beta } ,
+$$
+
+where $s$ denotes the speaker ID, and $c \in [ C ]$ denotes there are $C$ conditional layer normalizations in the decoder (the number of decoder layer is $( C - 1 ) / 2$ since each layer has two conditional layer normalizations corresponding to self-attention and feed-forward network in Transformer, and there is an additional layer normalization at the final output) and each uses different conditional matrices.
+
+# 2.3 PIPELINE OF ADASPEECH
+
+We list the pre-training, fine-tuning and inference pipeline of AdaSpeech in Algorithm 1. During fine-tuning, we only fine-tune the two matrices $W _ { c } ^ { \gamma }$ and $W _ { c } ^ { \beta }$ in each conditional layer normalization in decoder and the speaker embedding $E ^ { s }$ , fixing other model parameters including the utterance-level and phoneme-level acoustic encoders and phoneme-level acoustic predictor as described in Section 2.1. During inference, we do not directly use the two matrices $W _ { c } ^ { \gamma }$ and $W _ { c } ^ { \beta }$ in each conditional layer normalization since they still have large parameters. Instead we use the two matrices to calculate each scale and bias vector $\gamma _ { c } ^ { s }$ and $\beta _ { c } ^ { s }$ from speaker embedding $E _ { s }$ according to Equation 1 considering $E _ { s }$ is fixed in inference. In this way, we can save a lot of memory storage5.
+
+Algorithm 1 Pre-training, fine-tuning and inference of AdaSpeech
+
+1: Pre-training: Train the AdaSpeech model $\theta$ with source training data $D$ .   
+2: Fine-tuning: Fine-tune $W _ { c } ^ { \gamma }$ and $W _ { c } ^ { \beta }$ in each conditional layer normalization $c \in [ C ]$ and speaker embedding $E ^ { s }$ with the adaptation data $D ^ { s }$ for each custom speaker/voice $s$ .   
+3: Inference: Deployment: 1) Calculate $\gamma _ { c , } ^ { s } \beta _ { c } ^ { s }$ in each conditional layer normalization $c \in [ C ]$ , and get the parameters $\theta ^ { s } = \{ \{ \gamma _ { c } ^ { s } , \beta _ { c } ^ { s } \} _ { c = 1 } ^ { C } , E ^ { s } \}$ for speaker $s$ . 2) Deploy the shared model parameters $\tilde { \theta }$ (not fine-tuned in $\theta$ during adaptation) and speaker specific parameters $\theta ^ { s }$ for $s$ . Inference: Use $\tilde { \theta }$ and $\theta ^ { s }$ to synthesize custom voice for speaker $s$ .
+
+# 3 EXPERIMENTAL SETUP
+
+Datasets We train the AdaSpeech source model on LibriTTS (Zen et al., 2019) dataset, which is a multi-speaker corpus (2456 speakers) derived from LibriSpeech (Panayotov et al., 2015) and contains 586 hours speech data. In order to evaluate AdaSpeech in custom voice scenario, we adapt the source model to the voices in other datasets including VCTK (Veaux et al., 2016) (a multi-speaker datasets with 108 speakers and 44 hours speech data) and LJSpeech (Ito, 2017) (a single-speaker high-quality dataset with 24 hours speech data), which have different acoustic conditions from LibriTTS. As a comparison, we also adapt the source model to the voices in the same LibriTTS dataset.
+
+We randomly choose several speakers (including both male and female) from the training set of LibriTTS and VCTK and the only single speaker from the training set of LJSpeech for adaptation. For each chosen speaker, we randomly choose $K = 2 0$ sentences for adaptation and also study the effects of smaller $K$ in experiment part. We use all the speakers in the training set of LibriTTS (exclude those chosen for adaptation) to train the source AdaSpeech model, and use the original test sets in these datasets corresponding to the adaptation speakers to evaluate the adaptation voice quality.
+
+We conduct the following preprocessing on the speech and text data in these corpora: 1) convert the sampling rate of all speech data to 16kHz; 2) extract the mel-spectrogram with $1 2 . 5 \mathrm { m s }$ hop size and $5 0 \mathrm { m s }$ window size following the common practice in Shen et al. (2018); Ren et al. (2019); 3) convert text sequence into phoneme sequence with grapheme-to-phoneme conversion (Sun et al., 2019) and take phoneme as the encoder input.
+
+Model Configurations The model of AdaSpeech follows the basic structure in FastSpeech 2 (Ren et al., 2021), which consists of 4 feed-forward Transformer blocks for the phoneme encoder and melspectrogram decoder. The hidden dimension (including the phoneme embedding, speaker embedding, the hidden in self-attention, and the input and output hidden of feed-forward network) is set to 256. The number of attention heads, the feed-forward filter size and kernel size are set to 2, 1024 and 9 respectively. The output linear layer converts the 256-dimensional hidden into 80-dimensional mel-spectrogram. Other model configurations follow Ren et al. (2021) unless otherwise stated.
+
+The phoneme-level acoustic encoder (Figure 2c) and predictor (Figure 2d) share the same structure, which consists of 2 convolutional layers with filter size and kernel size of 256 and 3 respectively, and a linear layer to compress the hidden to a dimension of 4 (we choose the dimension of 4 according to our preliminary study and is also consistent with previous works (Sun et al., 2020; Zeng et al., 2020)). We use MFA (McAuliffe et al., 2017) to extract the alignment between the phoneme and mel-spectrogram sequence, which is used to prepare the input of the phoneme-level acoustic encoder. We also tried to leverage VQ-VAE (Sun et al., 2020) into the phoneme-level acoustic encoder but found no obvious gains. The utterance-level acoustic encoder consists of 2 convolutional layers with filter size, kernel size and stride size of 256, 5 and 3, and a pooling layer to obtain a single vector.
+
+Training, Adaptation and Inference In the source model training process, we first train AdaSpeech for 60,000 steps, and all the model parameters are optimized except the parameters of phoneme-level acoustic predictor. Then we train AdaSpeech and the phoneme-level acoustic predictor jointly for the remaining 40,000 steps, where the output hidden of the phoneme-level acoustic encoder is used as the label (the gradient is stopped to prevent flowing back to the phoneme-level acoustic encoder) to train the phoneme-level acoustic predictor with mean square error (MSE) loss. We train AdaSpeech on 4 NVIDIA P40 GPUs and each GPU has a batch size of about 12,500 speech frames. Adam optimizer is used with $\beta _ { 1 } = 0 . 9$ , $\beta _ { 2 } = 0 . 9 8$ , $\epsilon = 1 0 ^ { - 9 }$ .
+
+In the adaptation process, we fine-tune AdaSpeech on 1 NVIDIA P40 GPU for 2000 steps, where only the parameters of speaker embedding and conditional layer-normalization are optimized. In the inference process, the utterance-level acoustic conditions are extracted from another reference speech of the speaker, and the phoneme-level acoustic conditions are predicted from phoneme-level acoustic predictor. We use MelGAN (Kumar et al., 2019) as the vocoder to synthesize waveform from the generated mel-spectrogram.
+
+# 4 RESULTS
+
+In this section, we first evaluate the quality of the adaptation voices of AdaSpeech, and conduct ablation study to verify the effectiveness of each component in AdaSpeech, and finally we show some analyses of our method.
+
+# 4.1 THE QUALITY OF ADAPTATION VOICE
+
+We evaluate the quality of adaption voices in terms of naturalness (how the synthesized voices sound natural like human) and similarity (how the synthesized voices sound similar to this speaker). Therefore, we conduct human evaluations with MOS (mean opinion score) for naturalness and SMOS (similarity MOS) for similarity. Each sentence is listened by 20 judgers. For VCTK and LibriTTS, we average the MOS and SMOS scores of multiple adapted speakers as the final scores. We compare AdaSpeech with several settings: 1) GT, the ground-truth recordings; 2) GT mel $^ +$ Vocoder, using ground-truth mel-spectrogram to synthesize waveform with MelGAN vocoder; 3) Baseline (spk emb), a baseline system based on FastSpeech2 which only fine-tunes the speaker embedding during adaptation, and can be regarded as our lower bound; 4) Baseline (decoder), another baseline system based on FastSpeech2 which fine-tunes the whole decoder during adaptation, and can be regarded as a strong comparable system since it uses more parameters during adaptation; 5) AdaSpeech, our proposed AdaSpeech system with utterance-/phoneme-level acoustic condition modeling and conditional layer normalization during adaptation6.
+
+Table 1: The MOS and SMOS scores with $9 5 \%$ confidence intervals when adapting the source AdaSpeech model (trained on LibriTTS) to LJSpeech, VCTK and LibriTTS datasets. The third column shows the number of additional parameters for each custom voice during adaptation (the number in bracket shows the number of parameters in inference following the practice in Section 2.3).   
+
+<table><tr><td>Metric</td><td>Setting</td><td>|#Params/Speaker</td><td>LJSpeech</td><td>VCTK</td><td>LibriTTS</td></tr><tr><td rowspan="5">MOS</td><td>GT</td><td>/</td><td>3.98±0.12</td><td>3.87± 0.11</td><td>3.72 ± 0.12</td></tr><tr><td>GT mel + Vocoder</td><td>/</td><td>3.75 ±0.10</td><td>3.74 ±0.11</td><td>3.65 ± 0.12</td></tr><tr><td>Baseline (spk emb) Baseline (decoder)</td><td>256 (256) 14.1M (14.1M)</td><td>2.37 ± 0.14</td><td>2.36 ±0.10</td><td>3.02±0.13</td></tr><tr><td></td><td></td><td>3.44 ± 0.13</td><td>3.35 ± 0.12</td><td>3.51 ±0.11</td></tr><tr><td>AdaSpeech</td><td>1.2M (4.9K)</td><td>3.45 ± 0.11</td><td>3.39 ±0.10</td><td>3.55± 0.12</td></tr><tr><td rowspan="5">SMOS</td><td>GT</td><td>/</td><td>4.36 ± 0.11</td><td>4.44 ± 0.10</td><td>4.31 ± 0.07</td></tr><tr><td>GT mel + Vocoder</td><td>/</td><td>4.29 ± 0.11</td><td>4.36 ± 0.11</td><td>4.31± 0.07</td></tr><tr><td>Baseline (spk emb)</td><td>256 (256)</td><td>2.79 ± 0.19</td><td>3.34± 0.19</td><td>4.00 ± 0.12</td></tr><tr><td>Baseline (decoder)</td><td>14.1M (14.1M)</td><td>3.57± 0.12</td><td>3.90± 0.12</td><td>4.10 ±0.10</td></tr><tr><td> AdaSpeech</td><td>1.2M (4.9K)</td><td>3.59 ± 0.15</td><td>3.96± 0.15</td><td>4.13± 0.09</td></tr></table>
+
+The MOS and SMOS results are shown in Table 1. We have several observations: 1) Adapting the model (trained on LibriTTS) to the cross-domain datasets (LJSpeech and VCTK) is more difficult than adapting to the in-domain datasets (LibriTTS), since the MOS and SMOS gap between the adaptation models (two baselines and AdaSpeech) and the ground-truth mel $^ +$ vocoder setting is bigger on cross-domain datasets7. This also confirms the challenges of modeling different acoustic conditions in custom voice scenarios. 2) Compared with only fine-tuning speaker embedding, i.e., Baseline (spk emb), AdaSpeech achieves significant improvements in terms of both MOS and SMOS in the three adaptation datasets, by only leveraging slightly more parameters in conditional layer normalization. We also analyze in next subsection (Table 3) that even if we increase the adaptation parameters of baseline to match or surpass that in AdaSpeech, it still performs much worse than AdaSpeech. 3) Compared with fine-tuning the whole decoder, i.e., Baseline (decoder), AdaSpeech achieves slightly better quality in both MOS and SMOS and importantly with much smaller adaptation parameters, which demonstrates the effectiveness and efficiency of our proposed acoustic condition modeling and conditional layer normalization. Note that fine-tuning the whole decoder causes too much adaptation parameters that cannot satisfy the custom voice scenario.
+
+# 4.2 METHOD ANALYSIS
+
+In this section, we first conduct ablation studies to verify the effectiveness of each component in AdaSpeech, including utterance-level and phonemelevel acoustic condition modeling, and conditional layer normalization, and then conduct more detailed analyses on our proposed AdaSpeech.
+
+Table 2: The CMOS of the ablation study on VCTK. UL-ACM and PL-ACM represents utterance-level and phoneme-level acoustic condition modeling, and CLN represents conditional layer normalization.   
+
+<table><tr><td>Setting</td><td>CMOS</td></tr><tr><td>AdaSpeech</td><td>0</td></tr><tr><td>AdaSpeech w/o UL-ACM AdaSpeech w/o PL-ACM AdaSpeech w/o CLN</td><td>-0.12 -0.21 -0.14</td></tr></table>
+
+Ablation Study We compare the CMOS (comparison MOS) of the adaptation voice quality when removing each component in AdaSpeech on VCTK testset (each sentence is listened by 20 judgers). Specifically, when removing conditional layer normalization, we only fine-tune the speaker embedding. From Table 2, we can see that removing utterance-level and phoneme-level acoustic modeling, and conditional layer normalization all result in performance drop in voice quality, demonstrating the effectiveness of each component in AdaSpeech.
+
+Analyses on Acoustic Condition Modeling We analyze the vectors extracted from the utterancelevel acoustic encoder for several speakers on LibriTTS datasets. We use t-SNE (Maaten & Hinton,
+
+![](images/20d44f231397740e61ebc70e686f9e8cb055d74084454170043752107ac8df7c.jpg)  
+Figure 4: (a) The visualization of utterance-level acoustic vectors for several speakers (each number in the legend represents a speaker ID in LibriTTS datasets). (b) The MOS of different adaptation data on LJSpeech and VCTK.
+
+2008) to illustrate them in Figure 4a, where each point represents an utterance-level vector and each color belongs to the same speaker. It can be seen that different utterances of the same speaker are clustered together but have difference in acoustic conditions. There are some exceptions, such as the two pink points one blue point in the brown solid circle. According to our investigation on the corresponding speech data, these points correspond to the utterances with short and emotional voice, and thus are close to each other although belonging to different speakers.
+
+Analyses on Conditional Layer Normalization We further compare conditional layer normalization (CLN) with other two settings: 1) $\mathrm { L N } +$ fine-tune scale/bias: removing the condition on speaker embedding, and only fine-tuning scale/bias in layer normalization and speaker embedding; 2) $\mathrm { ~ L N ~ } +$ fine-tuning others: removing the condition on speaker embedding, and instead fine-tuning other (similar or even larger amount of) parameters in the decoder8. The CMOS evaluations are shown in Table 3. It can be seen that both settings result in worse quality compared with conditional layer normalization, which verifies its effectiveness.
+
+<table><tr><td>Setting CMOS</td></tr><tr><td>CLN 0</td></tr><tr><td>LN + fine-tune scale/bias -0.18</td></tr><tr><td>LN + fine-tune others -0.24</td></tr></table>
+
+Table 3: The CMOS on VCTK for the comparison of conditional layer normalization.
+
+Varying Adaptation Data We study the voice quality with different amount of adaptation data (fewer than the default setting) on VCTK and LJSpeech, and conduct MOS evaluation as shown in Figure 4b. It can be seen that the voice quality continue drops when adaptation data decreases, and drops quickly when the adaptation data is fewer than 10 sentences.
+
+# 5 CONCLUSIONS
+
+In this paper, we have developed AdaSpeech, an adaptive TTS system to support the distinctive requirements in custom voice. We propose acoustic condition modeling to make the source TTS model more adaptable for custom voice with various acoustic conditions. We further design conditional layer normalization to improve the adaptation efficiency: fine-tuning few model parameters to achieve high voice quality. We finally present the pipeline of pre-training, fine-tuning and inference in AdaSpeech for custom voice. Experiment results demonstrate that AdaSpeech can support custom voice with different acoustic conditions with few memory storage and at the same time with high voice quality. For future work, we will further improve the modeling of acoustic conditions in the source TTS model and study more diverse acoustic conditions such as noisy speech in custom voice. We will also investigate the adaptation setting with untranscribed data (Yan et al., 2021) and further compress the model size (Luo et al., 2021) to support more custom voices.
+
+# REFERENCES
+
+Sercan Arik, Jitong Chen, Kainan Peng, Wei Ping, and Yanqi Zhou. Neural voice cloning with a few samples. In Advances in Neural Information Processing Systems, pp. 10019–10029, 2018.
+
+Sercan O Arik, Mike Chrzanowski, Adam Coates, Gregory Diamos, Andrew Gibiansky, Yongguo Kang, Xian Li, John Miller, Andrew $\mathrm { N g }$ , Jonathan Raiman, et al. Deep voice: Real-time neural text-to-speech. arXiv preprint arXiv:1702.07825, 2017.
+
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.
+
+Mingjian Chen, Xu Tan, Yi Ren, Jin Xu, Hao Sun, Sheng Zhao, and Tao Qin. Multispeech: Multispeaker text to speech with transformer. Proc. Interspeech 2020, pp. 4024–4028, 2020.
+
+Yutian Chen, Yannis Assael, Brendan Shillingford, David Budden, Scott Reed, Heiga Zen, Quan Wang, Luis C Cobo, Andrew Trask, Ben Laurie, et al. Sample efficient adaptive text-to-speech. arXiv preprint arXiv:1809.10460, 2018.
+
+Erica Cooper, Cheng-I Lai, Yusuke Yasuda, Fuming Fang, Xin Wang, Nanxin Chen, and Junichi Yamagishi. Zero-shot multi-speaker text-to-speech with state-of-the-art neural speaker embeddings. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6184–6188. IEEE, 2020.
+
+Andrew Gibiansky, Sercan Arik, Gregory Diamos, John Miller, Kainan Peng, Wei Ping, Jonathan Raiman, and Yanqi Zhou. Deep voice 2: Multi-speaker neural text-to-speech. In Advances in neural information processing systems, pp. 2962–2970, 2017.
+
+Keith Ito. The lj speech dataset. https://keithito.com/LJ-Speech-Dataset/, 2017.
+
+Ye Jia, Yu Zhang, Ron Weiss, Quan Wang, Jonathan Shen, Fei Ren, Patrick Nguyen, Ruoming Pang, Ignacio Lopez Moreno, Yonghui Wu, et al. Transfer learning from speaker verification to multispeaker text-to-speech synthesis. In Advances in neural information processing systems, pp. 4480–4490, 2018.
+
+Jaehyeon Kim, Sungwon Kim, Jungil Kong, and Sungroh Yoon. Glow-tts: A generative flow for text-to-speech via monotonic alignment search. arXiv preprint arXiv:2005.11129, 2020.
+
+Zvi Kons, Slava Shechtman, Alex Sorin, Carmel Rabinovitz, and Ron Hoory. High quality, lightweight and adaptable tts using lpcnet. arXiv preprint arXiv:1905.00590, 2019.
+
+Kundan Kumar, Rithesh Kumar, Thibault de Boissiere, Lucas Gestin, Wei Zhen Teoh, Jose Sotelo, Alexandre de Brébisson, Yoshua Bengio, and Aaron C Courville. Melgan: Generative adversarial networks for conditional waveform synthesis. In Advances in Neural Information Processing Systems, pp. 14910–14921, 2019.
+
+Chao Li, Xiaokong Ma, Bing Jiang, Xiangang Li, Xuewei Zhang, Xiao Liu, Ying Cao, Ajay Kannan, and Zhenyao Zhu. Deep speaker: an end-to-end neural speaker embedding system. arXiv preprint arXiv:1705.02304, 2017.
+
+Renqian Luo, Xu Tan, Rui Wang, Tao Qin, Jinzhu Li, Sheng Zhao, Enhong Chen, and Tie-Yan Liu. Lightspeech: Lightweight and fast text to speech with neural architecture search. In 2021 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 2021.
+
+Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of machine learning research, 9(Nov):2579–2605, 2008.
+
+Michael McAuliffe, Michaela Socolof, Sarah Mihuc, Michael Wagner, and Morgan Sonderegger. Montreal forced aligner: Trainable text-speech alignment using kaldi. In Interspeech, pp. 498–502, 2017.
+
+Henry B Moss, Vatsal Aggarwal, Nishant Prateek, Javier González, and Roberto Barra-Chicote. Boffin tts: Few-shot speaker adaptation by bayesian optimization. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 7639–7643. IEEE, 2020.
+
+Vassil Panayotov, Guoguo Chen, Daniel Povey, and Sanjeev Khudanpur. Librispeech: an asr corpus based on public domain audio books. In 2015 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5206–5210. IEEE, 2015.
+
+Kainan Peng, Wei Ping, Zhao Song, and Kexin Zhao. Non-autoregressive neural text-to-speech. ICML, 2020.
+
+Wei Ping, Kainan Peng, Andrew Gibiansky, Sercan O. Arik, Ajay Kannan, Sharan Narang, Jonathan Raiman, and John Miller. Deep voice 3: 2000-speaker neural text-to-speech. In International Conference on Learning Representations, 2018.
+
+Yi Ren, Yangjun Ruan, Xu Tan, Tao Qin, Sheng Zhao, Zhou Zhao, and Tie-Yan Liu. Fastspeech: Fast, robust and controllable text to speech. In NeurIPS, 2019.
+
+Yi Ren, Chenxu Hu, Xu Tan, Tao Qin, Sheng Zhao, Zhou Zhao, and Tie-Yan Liu. Fastspeech 2: Fast and high-quality end-to-end text-to-speech. In ICLR, 2021.
+
+Jonathan Shen, Ruoming Pang, Ron J Weiss, Mike Schuster, Navdeep Jaitly, Zongheng Yang, Zhifeng Chen, Yu Zhang, Yuxuan Wang, Rj Skerrv-Ryan, et al. Natural tts synthesis by conditioning wavenet on mel spectrogram predictions. In 2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 4779–4783. IEEE, 2018.
+
+Guangzhi Sun, Yu Zhang, Ron J Weiss, Yuan Cao, Heiga Zen, Andrew Rosenberg, Bhuvana Ramabhadran, and Yonghui Wu. Generating diverse and natural text-to-speech samples using a quantized fine-grained vae and autoregressive prosody prior. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6699–6703. IEEE, 2020.
+
+Hao Sun, Xu Tan, Jun-Wei Gan, Hongzhi Liu, Sheng Zhao, Tao Qin, and Tie-Yan Liu. Token-level ensemble distillation for grapheme-to-phoneme conversion. In INTERSPEECH, 2019.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017.
+
+Christophe Veaux, Junichi Yamagishi, Kirsten MacDonald, et al. Superseded-cstr vctk corpus: English multi-speaker corpus for cstr voice cloning toolkit. 2016.
+
+Li Wan, Quan Wang, Alan Papir, and Ignacio Lopez Moreno. Generalized end-to-end loss for speaker verification. In 2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 4879–4883. IEEE, 2018.
+
+Yuxuan Wang, RJ Skerry-Ryan, Daisy Stanton, Yonghui Wu, Ron J Weiss, Navdeep Jaitly, Zongheng Yang, Ying Xiao, Zhifeng Chen, Samy Bengio, et al. Tacotron: Towards end-to-end speech synthesis. arXiv preprint arXiv:1703.10135, 2017.
+
+Yuzi Yan, Xu Tan, Bohan Li, Tao Qin, Sheng Zhao, Yuan Shen, and Tie-Yan Liu. Adaspeech 2: Adaptive text to speech with untranscribed data. In 2021 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 2021.
+
+Heiga Zen, Viet Dang, Rob Clark, Yu Zhang, Ron J Weiss, Ye Jia, Zhifeng Chen, and Yonghui Wu. Libritts: A corpus derived from librispeech for text-to-speech. arXiv preprint arXiv:1904.02882, 2019.
+
+Zhen Zeng, Jianzong Wang, Ning Cheng, and Jing Xiao. Prosody learning mechanism for speech synthesis system without text length limit. arXiv preprint arXiv:2008.05656, 2020.
+
+Chen Zhang, Yi Ren, Xu Tan, Jinglin Liu, Kejun Zhang, Tao Qin, Sheng Zhao, and Tie-Yan Liu. Denoispeech: Denoising text to speech with frame-level noise modeling. In 2021 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 2021.
+
+Zewang Zhang, Qiao Tian, Heng Lu, Ling-Hui Chen, and Shan Liu. Adadurian: Few-shot adaptation for neural text-to-speech with durian. arXiv preprint arXiv:2005.05642, 2020.

parse/train/Drynvt7gg4L/Drynvt7gg4L_content_list.json

@@ -0,0 +1,1170 @@
+[
+    {
+        "type": "text",
+        "text": "ADASPEECH: ADAPTIVE TEXT TO SPEECH FOR CUSTOM VOICE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            741,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mingjian Chen∗, Xu Tan∗, Bohan Li, Yanqing Liu, Tao Qin, Sheng Zhao, Tie-Yan Liu   \nMicrosoft Research Asia, Microsoft Azure Speech   \n{xuta,taoqin,szhao,tyliu}@microsoft.com ",
+        "bbox": [
+            184,
+            169,
+            772,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Custom voice, a specific text to speech (TTS) service in commercial speech platforms, aims to adapt a source TTS model to synthesize personal voice for a target speaker using few speech from her/him. Custom voice presents two unique challenges for TTS adaptation: 1) to support diverse customers, the adaptation model needs to handle diverse acoustic conditions which could be very different from source speech data, and 2) to support a large number of customers, the adaptation parameters need to be small enough for each target speaker to reduce memory usage while maintaining high voice quality. In this work, we propose AdaSpeech, an adaptive TTS system for high-quality and efficient customization of new voices. We design several techniques in AdaSpeech to address the two challenges in custom voice: 1) To handle different acoustic conditions, we model the acoustic information in both utterance and phoneme level. Specifically, we use one acoustic encoder to extract an utterance-level vector and another one to extract a sequence of phoneme-level vectors from the target speech during pre-training and fine-tuning; in inference, we extract the utterance-level vector from a reference speech and use an acoustic predictor to predict the phonemelevel vectors. 2) To better trade off the adaptation parameters and voice quality, we introduce conditional layer normalization in the mel-spectrogram decoder of AdaSpeech, and fine-tune this part in addition to speaker embedding for adaptation. We pre-train the source TTS model on LibriTTS datasets and fine-tune it on VCTK and LJSpeech datasets (with different acoustic conditions from LibriTTS) with few adaptation data, e.g., 20 sentences, about 1 minute speech. Experiment results show that AdaSpeech achieves much better adaptation quality than baseline methods, with only about 5K specific parameters for each speaker, which demonstrates its effectiveness for custom voice. The audio samples are available at https://speechresearch.github.io/adaspeech/. ",
+        "bbox": [
+            232,
+            281,
+            766,
+            640
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            667,
+            336,
+            683
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Text to speech (TTS) aims to synthesize natural and intelligible voice from text, and attracts a lot of interests in machine learning community (Arik et al., 2017; Wang et al., 2017; Gibiansky et al., 2017; Ping et al., 2018; Shen et al., 2018; Ren et al., 2019). TTS models can synthesize natural human voice when training with a large amount of high-quality and single-speaker recordings (Ito, 2017), and has been extended to multi-speaker scenarios (Gibiansky et al., 2017; Ping et al., 2018; Zen et al., 2019; Chen et al., 2020) using multi-speaker corpora (Panayotov et al., 2015; Veaux et al., 2016; Zen et al., 2019). However, these corpora contain a fixed set of speakers where each speaker still has a certain amount of speech data. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            810
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Nowadays, custom voice has attracted increasing interests in different application scenarios such as personal assistant, news broadcast and audio navigation, and has been widely supported in commercial speech platforms (some custom voice services include Microsoft Azure, Amazon AWS and Google Cloud). In custom voice, a source TTS model is usually adapted on personalized voices with few adaptation data, since the users of custom voice prefer to record as few adaptation data as possible (several minutes or seconds) for convenient purpose. Few adaptation data presents great challenges on the naturalness and similarity of adapted voice. Furthermore, there are also several distinctive challenges in custom voice: 1) The recordings of the custom users are usually of different acoustic conditions from the source speech data (the data to train the source TTS model). For example, the adaptation data is usually recorded with diverse speaking prosodies, styles, emotions, accents and recording environments. The mismatch in these acoustic conditions makes the source model difficult to generalize and leads to poor adaptation quality. 2) When adapting the source TTS model to a new voice, there is a trade-off between the fine-tuning parameters and voice quality. Generally speaking, more adaptation parameters will usually result in better voice quality, which, as a result, increases the memory storage and serving cost1. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While previous works in TTS adaptation have well considered the few adaptation data setting in custom voice, they have not fully addressed the above challenges. They fine-tune the whole model (Chen et al., 2018; Kons et al., 2019) or decoder part (Moss et al., 2020; Zhang et al., 2020), achieving good quality but causing too many adaptation parameters. Reducing the amount of adaptation parameters is necessary for the deployment of commercialized custom voice. Otherwise, the memory storage would explode as the increase of users. Some works only fine-tune the speaker embedding (Arik et al., 2018; Chen et al., 2018), or train a speaker encoder module (Arik et al., 2018; Jia et al., 2018; Cooper et al., 2020; Li et al., 2017; Wan et al., 2018) that does not need fine-tuning during adaptation. While these approaches lead a light-weight and efficient adaptation, they result in poor adaptation quality. Moreover, most previous works assume the source speech data and adaptation data are in the same domain and do not consider the setting with different acoustic conditions, which is not practical in custom voice scenarios. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            402
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose AdaSpeech, an adaptive TTS model for high-quality and efficient customization of new voice. AdaSpeech employ a three-stage pipeline for custom voice: 1) pre-training; 2) fine-tuning; 3) inference. During the pre-training stage, the TTS model is trained on large-scale multi-speaker datasets, which can ensure the TTS model to cover diverse text and speaking voices that is helpful for adaptation. During the fine-tuning stage, the source TTS model is adapted on a new voice by fine-tuning (a part of) the model parameters on the limited adaptation data with diverse acoustic conditions. During the inference stage, both the unadapted part (parameters shared by all custom voices) and the adapted part (each custom voice has specific adapted parameters) of the TTS model are used for the inference request. We build AdaSpeech based on the popular non-autoregressive TTS models (Ren et al., 2019; Peng et al., 2020; Kim et al., 2020; Ren et al., 2021) and further design several techniques to address the challenges in custom voice: ",
+        "bbox": [
+            173,
+            410,
+            825,
+            561
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Acoustic condition modeling. In order to handle different acoustic conditions for adaptation, we model the acoustic conditions in both utterance and phoneme level in pre-training and fine-tuning. Specifically, we use two acoustic encoders to extract an utterance-level vector and a sequence of phoneme-level vectors from the target speech, which are taken as the input of the mel-spectrogram decoder to represent the global and local acoustic conditions respectively. In this way, the decoder can predict speech in different acoustic conditions based on these acoustic information. Otherwise, the model would memorize the acoustic conditions and cannot generalize well. In inference, we extract the utterance-level vector from a reference speech and use another acoustic predictor that is built upon the phoneme encoder to predict the phoneme-level vectors. ",
+        "bbox": [
+            174,
+            574,
+            825,
+            700
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Conditional layer normalization. To fine-tune as small amount of parameters as possible while ensuring the adaptation quality, we modify the layer normalization (Ba et al., 2016) in the melspectrogram decoder in pre-training, by using speaker embedding as the conditional information to generate the scale and bias vector in layer normalization. In fine-tuning, we only adapt the parameters related to the conditional layer normalization. In this way, we can greatly reduce adaptation parameters and thus memory storage2 compared with fine-tuning the whole model, but maintain high-quality adaptation voice thanks to the flexibility of conditional layer normalization. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            803
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the effectiveness of our proposed AdaSpeech for custom voice, we conduct experiments to train the TTS model on LibriTTS datasets and adapt the model on VCTK and LJSpeech datasets with different adaptation settings. Experiment results show that AdaSpeech achieves better adaptation quality in terms of MOS (mean opinion score) and SMOS (similarity MOS) than baseline methods, with ",
+        "bbox": [
+            174,
+            815,
+            825,
+            871
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "only about 5K specific parameters for each speaker, demonstrating its effectiveness for custom voice.   \nAudio samples are available at https://speechresearch.github.io/adaspeech/. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 ADASPEECH ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            142,
+            312,
+            159
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first describe the overall design of our proposed AdaSpeech, and then introduce the key techniques to address the challenges in custom voice. At last, we list the pre-training, finetuning and inference pipeline of AdaSpeech for custom voice. ",
+        "bbox": [
+            174,
+            174,
+            612,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The model structure of AdaSpeech is shown in Figure 1. We adopt FastSpeech 2 (Ren et al., 2021) as the model backbone considering the FastSpeech (Ren et al., 2019; 2021) series are one of the most popular models in non-autoregressive TTS. The basic model backbone consists of a phoneme encoder, a mel-spectrogram decoder, and a variance adaptor which provides variance information including duration, pitch and energy into the phoneme hidden sequence following Ren et al. (2021). As shown in Figure 1, we design two additional components to address the distinctive challenges in custom voice: 1) to support diverse customers, we use acoustic condition modeling to capture the diverse acoustic conditions of adaptation speech in different granularities; 2) to support a large number of customers with affordable memory storage, we use conditional layer normalization in decoder for efficient adaptation with few parameters while high voice quality. In the next subsections, we introduce the details of these components respectively. ",
+        "bbox": [
+            174,
+            237,
+            614,
+            416
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            417,
+            823,
+            444
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 ACOUSTIC CONDITION MODELING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            462,
+            455,
+            477
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In custom voice, the adaptation data can be spoken with diverse prosodies, styles, accents, and can be recorded under various environments, which can make the acoustic conditions far different from that in source speech data. This presents great challenges to adapt the source TTS model, since the source speech cannot cover all the acoustic conditions in custom voice. A practical way to alleviate this issue is to improve the adaptability (generalizability) of source TTS model. In text to speech, since the input text lacks enough acoustic conditions (such as speaker timbre, prosody and recording environments) to predict the target speech, the model tends to memorize and overfit on the training data (Ren et al., 2021), and has poor generalization during adaptation. A natural way to solve such problem is to provide corresponding acoustic conditions as input to make the model learn reasonable text-to-speech mapping towards better generalization instead of memorizing. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            627
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/b16230a0b3471c9cf7166d42bf87e2d4d83fb2c8fad20fc0c5c9c58c2c644de2.jpg",
+        "image_caption": [
+            "Figure 1: AdaSpeech. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            650,
+            176,
+            802,
+            372
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To better model the acoustic conditions with different granularities, we categorize the acoustic conditions in different levels as shown in Figure 2a: 1) speaker level, the coarse-grained acoustic conditions to capture the overall characteristics of a speaker; 2) utterance level, the fine-grained acoustic conditions in each utterance of a speaker; 3) phoneme level, the more fine-grained acoustic conditions in each phoneme of an utterance, such as accents on specific phonemes, pitches, prosodies and temporal environment noises3. Since speaker ID (embedding) is widely used to capture speakerlevel acoustic conditions in multi-speaker scenario (Chen et al., 2020), speaker embedding is used by default. We describe the utterance-level and phoneme-level acoustic condition modeling as follows. ",
+        "bbox": [
+            173,
+            633,
+            825,
+            746
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Utterance Level. We use an acoustic encoder to extract a vector from a reference speech, similar to Arik et al. (2018); Jia et al. (2018); Cooper et al. (2020), and then expand and add it to the phoneme hidden sequence to provide the utterance-level acoustic conditions. As shown in Figure 2b, the acoustic encoder consists of several convolutional layers and a mean pooling layer to get a single vector. The reference speech is the target speech during training, while a randomly chosen speech of this speaker during inference. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            842
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Phoneme Level. We use another acoustic encoder (shown in Figure 2c) to extract a sequence of phoneme-level vectors from the target speech and add it to the phoneme hidden sequence to provide the phoneme-level acoustic conditions4. In order to extract phoneme-level information from speech, we first average the speech frames corresponding to the same phoneme according to alignment between phoneme and mel-spectrogram sequence (shown in Figure 2a), to convert to length of speech frame sequence into the length of phoneme sequence, similar to Sun et al. (2020); Zeng et al. (2020). During inference, we use another phoneme-level acoustic predictor (shown in Figure 2d) which is built upon the original phoneme encoder to predict the phoneme-level vectors. ",
+        "bbox": [
+            176,
+            845,
+            821,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/1b8115e8378ff3f0bce5e8c218cc53e46a1027bcc95a6b54cc7689458e994c80.jpg",
+        "image_caption": [
+            "Figure 2: (a) The overall structure of acoustic condition modeling. (b) Utterance-level acoustic encoder. (c) Phoneme-level acoustic encoder, where phoneme-level mel means the mel-frames aligned to the same phoneme are averaged. (d) Phoneme-level acoustic predictor, where phoneme hiddens is the hidden sequence from the phoneme encoder in Figure 1. ‘Conv1D $( m , n ) $ means the kernel size and stride size in 1D convolution is $m$ and $n$ respectively. ‘LN’ means layer normalization. As shown in Figure 2a, the phoneme-level vectors are directly added element-wisely into the hidden sequence, and the utterance-level and speaker level vector/embedding are first expanded to the same length and then added element-wisely into the hidden sequence. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            71,
+            797,
+            252
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            189,
+            386,
+            825,
+            469
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Using speech encoders to extract a single vector or a sequence of vectors to represent the characteristics of a speech sequence has been adopted in previous works (Arik et al., 2018; Jia et al., 2018; Cooper et al., 2020; Sun et al., 2020; Zeng et al., 2020). They usually leverage them to improve the speaker timbre or prosody of the TTS model, or improve the controllability of the model. The key contribution in our acoustic condition modeling in this work is the novel perspective to model the diverse acoustic conditions in different granularities to make the source model more adaptable to different adaptation data. As analyzed in Section 4.2, utterance-level and phoneme-level acoustic modeling can indeed help the learning of acoustic conditions and is critical to ensure the adaptation quality. ",
+        "bbox": [
+            173,
+            482,
+            825,
+            607
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 CONDITIONAL LAYER NORMALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            626,
+            491,
+            638
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Achieving high adaptation quality while using small adaptation parameters is challenging. Previous works use zero-shot adaptation with speaker encoder (Arik et al., 2018; Jia et al., 2018; Cooper et al., 2020) or only fine-tune the speaker embedding cannot achieve satisfied quality. Can we greatly increase the voice quality at the cost of slightly more but negligible parameters? To this end, we analyze the model parameters of FastSpeech 2 (Ren et al., 2021), which is basically built upon the structure of Transformer (Vaswani et al., 2017), with a self-attention network and a feed-forward network in each Transformer block. Both the matrix multiplications in the query, key, value and output of self-attention and two-layer feed-forward networks are parameter-intensive, which is not efficient to adapt. We find that layer normalization (Ba et al., 2016) is adopted in each self-attention and feed-forward network in decoder, which can greatly influence the hidden activation and final prediction with a light-weight learnable scale vector $\\gamma$ and bias vector $\\beta$ : $\\begin{array} { r } { L N ( x ) = \\gamma \\frac { x - \\mu } { \\sigma } + \\beta } \\end{array}$ , where $\\mu$ and $\\sigma$ are the mean and variance of hidden vector $x$ . ",
+        "bbox": [
+            174,
+            651,
+            583,
+            762
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/a66e8ffc76fa99ca95e58f3c7f706be919dbfefddd07a11631defff56ae26599.jpg",
+        "image_caption": [
+            "Figure 3: Conditional LayerNorm. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            624,
+            625,
+            787,
+            729
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            763,
+            825,
+            859
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If we can determine the scale and bias vector in layer normalization with the corresponding speaker characteristics using a small conditional network, then we can fine-tune this conditional network when adapting to a new voice, and greatly reduce the adaptation parameters while ensuring the adaptation quality. As shown in Figure 3, the conditional network consists of two simple linear layers $W _ { c } ^ { \\gamma }$ and $\\hat W _ { c } ^ { \\beta }$ that take speaker embedding $E ^ { s }$ as input and output the scale and bias vector respectively: ",
+        "bbox": [
+            173,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/46d9158de490c6a92b43b8057a8662efbb9d97a2f42d97fafc32fd4cfce294d3.jpg",
+        "text": "$$\n\\gamma _ { c } ^ { s } = E ^ { s } * W _ { c } ^ { \\gamma } , \\beta _ { c } ^ { s } = E ^ { s } * W _ { c } ^ { \\beta } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            180,
+            609,
+            199
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $s$ denotes the speaker ID, and $c \\in [ C ]$ denotes there are $C$ conditional layer normalizations in the decoder (the number of decoder layer is $( C - 1 ) / 2$ since each layer has two conditional layer normalizations corresponding to self-attention and feed-forward network in Transformer, and there is an additional layer normalization at the final output) and each uses different conditional matrices. ",
+        "bbox": [
+            174,
+            205,
+            825,
+            262
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 PIPELINE OF ADASPEECH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            279,
+            393,
+            294
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We list the pre-training, fine-tuning and inference pipeline of AdaSpeech in Algorithm 1. During fine-tuning, we only fine-tune the two matrices $W _ { c } ^ { \\gamma }$ and $W _ { c } ^ { \\beta }$ in each conditional layer normalization in decoder and the speaker embedding $E ^ { s }$ , fixing other model parameters including the utterance-level and phoneme-level acoustic encoders and phoneme-level acoustic predictor as described in Section 2.1. During inference, we do not directly use the two matrices $W _ { c } ^ { \\gamma }$ and $W _ { c } ^ { \\beta }$ in each conditional layer normalization since they still have large parameters. Instead we use the two matrices to calculate each scale and bias vector $\\gamma _ { c } ^ { s }$ and $\\beta _ { c } ^ { s }$ from speaker embedding $E _ { s }$ according to Equation 1 considering $E _ { s }$ is fixed in inference. In this way, we can save a lot of memory storage5. ",
+        "bbox": [
+            173,
+            305,
+            825,
+            416
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Pre-training, fine-tuning and inference of AdaSpeech ",
+        "bbox": [
+            173,
+            425,
+            609,
+            439
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1: Pre-training: Train the AdaSpeech model $\\theta$ with source training data $D$ .   \n2: Fine-tuning: Fine-tune $W _ { c } ^ { \\gamma }$ and $W _ { c } ^ { \\beta }$ in each conditional layer normalization $c \\in [ C ]$ and speaker embedding $E ^ { s }$ with the adaptation data $D ^ { s }$ for each custom speaker/voice $s$ .   \n3: Inference: Deployment: 1) Calculate $\\gamma _ { c , } ^ { s } \\beta _ { c } ^ { s }$ in each conditional layer normalization $c \\in [ C ]$ , and get the parameters $\\theta ^ { s } = \\{ \\{ \\gamma _ { c } ^ { s } , \\beta _ { c } ^ { s } \\} _ { c = 1 } ^ { C } , E ^ { s } \\}$ for speaker $s$ . 2) Deploy the shared model parameters $\\tilde { \\theta }$ (not fine-tuned in $\\theta$ during adaptation) and speaker specific parameters $\\theta ^ { s }$ for $s$ . Inference: Use $\\tilde { \\theta }$ and $\\theta ^ { s }$ to synthesize custom voice for speaker $s$ . ",
+        "bbox": [
+            179,
+            444,
+            826,
+            547
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            568,
+            398,
+            584
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Datasets We train the AdaSpeech source model on LibriTTS (Zen et al., 2019) dataset, which is a multi-speaker corpus (2456 speakers) derived from LibriSpeech (Panayotov et al., 2015) and contains 586 hours speech data. In order to evaluate AdaSpeech in custom voice scenario, we adapt the source model to the voices in other datasets including VCTK (Veaux et al., 2016) (a multi-speaker datasets with 108 speakers and 44 hours speech data) and LJSpeech (Ito, 2017) (a single-speaker high-quality dataset with 24 hours speech data), which have different acoustic conditions from LibriTTS. As a comparison, we also adapt the source model to the voices in the same LibriTTS dataset. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            696
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We randomly choose several speakers (including both male and female) from the training set of LibriTTS and VCTK and the only single speaker from the training set of LJSpeech for adaptation. For each chosen speaker, we randomly choose $K = 2 0$ sentences for adaptation and also study the effects of smaller $K$ in experiment part. We use all the speakers in the training set of LibriTTS (exclude those chosen for adaptation) to train the source AdaSpeech model, and use the original test sets in these datasets corresponding to the adaptation speakers to evaluate the adaptation voice quality. ",
+        "bbox": [
+            174,
+            704,
+            825,
+            789
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We conduct the following preprocessing on the speech and text data in these corpora: 1) convert the sampling rate of all speech data to 16kHz; 2) extract the mel-spectrogram with $1 2 . 5 \\mathrm { m s }$ hop size and $5 0 \\mathrm { m s }$ window size following the common practice in Shen et al. (2018); Ren et al. (2019); 3) convert text sequence into phoneme sequence with grapheme-to-phoneme conversion (Sun et al., 2019) and take phoneme as the encoder input. ",
+        "bbox": [
+            174,
+            795,
+            825,
+            837
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Model Configurations The model of AdaSpeech follows the basic structure in FastSpeech 2 (Ren et al., 2021), which consists of 4 feed-forward Transformer blocks for the phoneme encoder and melspectrogram decoder. The hidden dimension (including the phoneme embedding, speaker embedding, the hidden in self-attention, and the input and output hidden of feed-forward network) is set to 256. The number of attention heads, the feed-forward filter size and kernel size are set to 2, 1024 and 9 respectively. The output linear layer converts the 256-dimensional hidden into 80-dimensional mel-spectrogram. Other model configurations follow Ren et al. (2021) unless otherwise stated. ",
+        "bbox": [
+            174,
+            147,
+            825,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The phoneme-level acoustic encoder (Figure 2c) and predictor (Figure 2d) share the same structure, which consists of 2 convolutional layers with filter size and kernel size of 256 and 3 respectively, and a linear layer to compress the hidden to a dimension of 4 (we choose the dimension of 4 according to our preliminary study and is also consistent with previous works (Sun et al., 2020; Zeng et al., 2020)). We use MFA (McAuliffe et al., 2017) to extract the alignment between the phoneme and mel-spectrogram sequence, which is used to prepare the input of the phoneme-level acoustic encoder. We also tried to leverage VQ-VAE (Sun et al., 2020) into the phoneme-level acoustic encoder but found no obvious gains. The utterance-level acoustic encoder consists of 2 convolutional layers with filter size, kernel size and stride size of 256, 5 and 3, and a pooling layer to obtain a single vector. ",
+        "bbox": [
+            174,
+            252,
+            825,
+            377
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training, Adaptation and Inference In the source model training process, we first train AdaSpeech for 60,000 steps, and all the model parameters are optimized except the parameters of phoneme-level acoustic predictor. Then we train AdaSpeech and the phoneme-level acoustic predictor jointly for the remaining 40,000 steps, where the output hidden of the phoneme-level acoustic encoder is used as the label (the gradient is stopped to prevent flowing back to the phoneme-level acoustic encoder) to train the phoneme-level acoustic predictor with mean square error (MSE) loss. We train AdaSpeech on 4 NVIDIA P40 GPUs and each GPU has a batch size of about 12,500 speech frames. Adam optimizer is used with $\\beta _ { 1 } = 0 . 9$ , $\\beta _ { 2 } = 0 . 9 8$ , $\\epsilon = 1 0 ^ { - 9 }$ . ",
+        "bbox": [
+            174,
+            392,
+            825,
+            503
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the adaptation process, we fine-tune AdaSpeech on 1 NVIDIA P40 GPU for 2000 steps, where only the parameters of speaker embedding and conditional layer-normalization are optimized. In the inference process, the utterance-level acoustic conditions are extracted from another reference speech of the speaker, and the phoneme-level acoustic conditions are predicted from phoneme-level acoustic predictor. We use MelGAN (Kumar et al., 2019) as the vocoder to synthesize waveform from the generated mel-spectrogram. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            594
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            614,
+            282,
+            630
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first evaluate the quality of the adaptation voices of AdaSpeech, and conduct ablation study to verify the effectiveness of each component in AdaSpeech, and finally we show some analyses of our method. ",
+        "bbox": [
+            176,
+            635,
+            825,
+            676
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 THE QUALITY OF ADAPTATION VOICE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            693,
+            480,
+            708
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the quality of adaption voices in terms of naturalness (how the synthesized voices sound natural like human) and similarity (how the synthesized voices sound similar to this speaker). Therefore, we conduct human evaluations with MOS (mean opinion score) for naturalness and SMOS (similarity MOS) for similarity. Each sentence is listened by 20 judgers. For VCTK and LibriTTS, we average the MOS and SMOS scores of multiple adapted speakers as the final scores. We compare AdaSpeech with several settings: 1) GT, the ground-truth recordings; 2) GT mel $^ +$ Vocoder, using ground-truth mel-spectrogram to synthesize waveform with MelGAN vocoder; 3) Baseline (spk emb), a baseline system based on FastSpeech2 which only fine-tunes the speaker embedding during adaptation, and can be regarded as our lower bound; 4) Baseline (decoder), another baseline system based on FastSpeech2 which fine-tunes the whole decoder during adaptation, and can be regarded as a strong comparable system since it uses more parameters during adaptation; 5) AdaSpeech, our proposed AdaSpeech system with utterance-/phoneme-level acoustic condition modeling and conditional layer normalization during adaptation6. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            900
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/0f6a09d6fb8b72ff96757b9c4d679b7d1184f5c57918e40a7bebaf2a432cd1f6.jpg",
+        "table_caption": [
+            "Table 1: The MOS and SMOS scores with $9 5 \\%$ confidence intervals when adapting the source AdaSpeech model (trained on LibriTTS) to LJSpeech, VCTK and LibriTTS datasets. The third column shows the number of additional parameters for each custom voice during adaptation (the number in bracket shows the number of parameters in inference following the practice in Section 2.3). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Metric</td><td>Setting</td><td>|#Params/Speaker</td><td>LJSpeech</td><td>VCTK</td><td>LibriTTS</td></tr><tr><td rowspan=\"5\">MOS</td><td>GT</td><td>/</td><td>3.98±0.12</td><td>3.87± 0.11</td><td>3.72 ± 0.12</td></tr><tr><td>GT mel + Vocoder</td><td>/</td><td>3.75 ±0.10</td><td>3.74 ±0.11</td><td>3.65 ± 0.12</td></tr><tr><td>Baseline (spk emb) Baseline (decoder)</td><td>256 (256) 14.1M (14.1M)</td><td>2.37 ± 0.14</td><td>2.36 ±0.10</td><td>3.02±0.13</td></tr><tr><td></td><td></td><td>3.44 ± 0.13</td><td>3.35 ± 0.12</td><td>3.51 ±0.11</td></tr><tr><td>AdaSpeech</td><td>1.2M (4.9K)</td><td>3.45 ± 0.11</td><td>3.39 ±0.10</td><td>3.55± 0.12</td></tr><tr><td rowspan=\"5\">SMOS</td><td>GT</td><td>/</td><td>4.36 ± 0.11</td><td>4.44 ± 0.10</td><td>4.31 ± 0.07</td></tr><tr><td>GT mel + Vocoder</td><td>/</td><td>4.29 ± 0.11</td><td>4.36 ± 0.11</td><td>4.31± 0.07</td></tr><tr><td>Baseline (spk emb)</td><td>256 (256)</td><td>2.79 ± 0.19</td><td>3.34± 0.19</td><td>4.00 ± 0.12</td></tr><tr><td>Baseline (decoder)</td><td>14.1M (14.1M)</td><td>3.57± 0.12</td><td>3.90± 0.12</td><td>4.10 ±0.10</td></tr><tr><td> AdaSpeech</td><td>1.2M (4.9K)</td><td>3.59 ± 0.15</td><td>3.96± 0.15</td><td>4.13± 0.09</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            826,
+            303
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The MOS and SMOS results are shown in Table 1. We have several observations: 1) Adapting the model (trained on LibriTTS) to the cross-domain datasets (LJSpeech and VCTK) is more difficult than adapting to the in-domain datasets (LibriTTS), since the MOS and SMOS gap between the adaptation models (two baselines and AdaSpeech) and the ground-truth mel $^ +$ vocoder setting is bigger on cross-domain datasets7. This also confirms the challenges of modeling different acoustic conditions in custom voice scenarios. 2) Compared with only fine-tuning speaker embedding, i.e., Baseline (spk emb), AdaSpeech achieves significant improvements in terms of both MOS and SMOS in the three adaptation datasets, by only leveraging slightly more parameters in conditional layer normalization. We also analyze in next subsection (Table 3) that even if we increase the adaptation parameters of baseline to match or surpass that in AdaSpeech, it still performs much worse than AdaSpeech. 3) Compared with fine-tuning the whole decoder, i.e., Baseline (decoder), AdaSpeech achieves slightly better quality in both MOS and SMOS and importantly with much smaller adaptation parameters, which demonstrates the effectiveness and efficiency of our proposed acoustic condition modeling and conditional layer normalization. Note that fine-tuning the whole decoder causes too much adaptation parameters that cannot satisfy the custom voice scenario. ",
+        "bbox": [
+            173,
+            388,
+            825,
+            597
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 METHOD ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            608,
+            354,
+            622
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first conduct ablation studies to verify the effectiveness of each component in AdaSpeech, including utterance-level and phonemelevel acoustic condition modeling, and conditional layer normalization, and then conduct more detailed analyses on our proposed AdaSpeech. ",
+        "bbox": [
+            174,
+            633,
+            517,
+            717
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/f0ae6d6caebcf00b31cfe68249141b9021546d91f8bb83c04fabe6ef5f8ee980.jpg",
+        "table_caption": [
+            "Table 2: The CMOS of the ablation study on VCTK. UL-ACM and PL-ACM represents utterance-level and phoneme-level acoustic condition modeling, and CLN represents conditional layer normalization. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Setting</td><td>CMOS</td></tr><tr><td>AdaSpeech</td><td>0</td></tr><tr><td>AdaSpeech w/o UL-ACM AdaSpeech w/o PL-ACM AdaSpeech w/o CLN</td><td>-0.12 -0.21 -0.14</td></tr></table>",
+        "bbox": [
+            547,
+            621,
+            805,
+            714
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Ablation Study We compare the CMOS (comparison MOS) of the adaptation voice quality when removing each component in AdaSpeech on VCTK testset (each sentence is listened by 20 judgers). Specifically, when removing conditional layer normalization, we only fine-tune the speaker embedding. From Table 2, we can see that removing utterance-level and phoneme-level acoustic modeling, and conditional layer normalization all result in performance drop in voice quality, demonstrating the effectiveness of each component in AdaSpeech. ",
+        "bbox": [
+            173,
+            733,
+            517,
+            801
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            178,
+            803,
+            823,
+            843
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Analyses on Acoustic Condition Modeling We analyze the vectors extracted from the utterancelevel acoustic encoder for several speakers on LibriTTS datasets. We use t-SNE (Maaten & Hinton, ",
+        "bbox": [
+            174,
+            859,
+            823,
+            887
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/20d44f231397740e61ebc70e686f9e8cb055d74084454170043752107ac8df7c.jpg",
+        "image_caption": [
+            "Figure 4: (a) The visualization of utterance-level acoustic vectors for several speakers (each number in the legend represents a speaker ID in LibriTTS datasets). (b) The MOS of different adaptation data on LJSpeech and VCTK. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            104,
+            794,
+            301
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "2008) to illustrate them in Figure 4a, where each point represents an utterance-level vector and each color belongs to the same speaker. It can be seen that different utterances of the same speaker are clustered together but have difference in acoustic conditions. There are some exceptions, such as the two pink points one blue point in the brown solid circle. According to our investigation on the corresponding speech data, these points correspond to the utterances with short and emotional voice, and thus are close to each other although belonging to different speakers. ",
+        "bbox": [
+            173,
+            366,
+            825,
+            449
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Analyses on Conditional Layer Normalization We further compare conditional layer normalization (CLN) with other two settings: 1) $\\mathrm { L N } +$ fine-tune scale/bias: removing the condition on speaker embedding, and only fine-tuning scale/bias in layer normalization and speaker embedding; 2) $\\mathrm { ~ L N ~ } +$ fine-tuning others: removing the condition on speaker embedding, and instead fine-tuning other (similar or even larger amount of) parameters in the decoder8. The CMOS evaluations are shown in Table 3. It can be seen that both settings result in worse quality compared with conditional layer normalization, which verifies its effectiveness. ",
+        "bbox": [
+            174,
+            465,
+            549,
+            606
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/f2ae598e272212dfc8f9698ce4fa960fb6de7964c596c9a24382866020661a5f.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 3: The CMOS on VCTK for the comparison of conditional layer normalization. "
+        ],
+        "table_body": "<table><tr><td>Setting CMOS</td></tr><tr><td>CLN 0</td></tr><tr><td>LN + fine-tune scale/bias -0.18</td></tr><tr><td>LN + fine-tune others -0.24</td></tr></table>",
+        "bbox": [
+            563,
+            470,
+            821,
+            544
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            178,
+            606,
+            691,
+            618
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Varying Adaptation Data We study the voice quality with different amount of adaptation data (fewer than the default setting) on VCTK and LJSpeech, and conduct MOS evaluation as shown in Figure 4b. It can be seen that the voice quality continue drops when adaptation data decreases, and drops quickly when the adaptation data is fewer than 10 sentences. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            690
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            712,
+            328,
+            728
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have developed AdaSpeech, an adaptive TTS system to support the distinctive requirements in custom voice. We propose acoustic condition modeling to make the source TTS model more adaptable for custom voice with various acoustic conditions. We further design conditional layer normalization to improve the adaptation efficiency: fine-tuning few model parameters to achieve high voice quality. We finally present the pipeline of pre-training, fine-tuning and inference in AdaSpeech for custom voice. Experiment results demonstrate that AdaSpeech can support custom voice with different acoustic conditions with few memory storage and at the same time with high voice quality. For future work, we will further improve the modeling of acoustic conditions in the source TTS model and study more diverse acoustic conditions such as noisy speech in custom voice. We will also investigate the adaptation setting with untranscribed data (Yan et al., 2021) and further compress the model size (Luo et al., 2021) to support more custom voices. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            886
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sercan Arik, Jitong Chen, Kainan Peng, Wei Ping, and Yanqi Zhou. Neural voice cloning with a few samples. In Advances in Neural Information Processing Systems, pp. 10019–10029, 2018. ",
+        "bbox": [
+            174,
+            125,
+            821,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sercan O Arik, Mike Chrzanowski, Adam Coates, Gregory Diamos, Andrew Gibiansky, Yongguo Kang, Xian Li, John Miller, Andrew $\\mathrm { N g }$ , Jonathan Raiman, et al. Deep voice: Real-time neural text-to-speech. arXiv preprint arXiv:1702.07825, 2017. ",
+        "bbox": [
+            174,
+            161,
+            823,
+            204
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016. ",
+        "bbox": [
+            171,
+            212,
+            823,
+            242
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mingjian Chen, Xu Tan, Yi Ren, Jin Xu, Hao Sun, Sheng Zhao, and Tao Qin. Multispeech: Multispeaker text to speech with transformer. Proc. Interspeech 2020, pp. 4024–4028, 2020. ",
+        "bbox": [
+            171,
+            250,
+            823,
+            280
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yutian Chen, Yannis Assael, Brendan Shillingford, David Budden, Scott Reed, Heiga Zen, Quan Wang, Luis C Cobo, Andrew Trask, Ben Laurie, et al. Sample efficient adaptive text-to-speech. arXiv preprint arXiv:1809.10460, 2018. ",
+        "bbox": [
+            174,
+            286,
+            826,
+            329
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Erica Cooper, Cheng-I Lai, Yusuke Yasuda, Fuming Fang, Xin Wang, Nanxin Chen, and Junichi Yamagishi. Zero-shot multi-speaker text-to-speech with state-of-the-art neural speaker embeddings. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6184–6188. IEEE, 2020. ",
+        "bbox": [
+            174,
+            337,
+            826,
+            393
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrew Gibiansky, Sercan Arik, Gregory Diamos, John Miller, Kainan Peng, Wei Ping, Jonathan Raiman, and Yanqi Zhou. Deep voice 2: Multi-speaker neural text-to-speech. In Advances in neural information processing systems, pp. 2962–2970, 2017. ",
+        "bbox": [
+            174,
+            401,
+            823,
+            445
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Keith Ito. The lj speech dataset. https://keithito.com/LJ-Speech-Dataset/, 2017. ",
+        "bbox": [
+            169,
+            452,
+            820,
+            468
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ye Jia, Yu Zhang, Ron Weiss, Quan Wang, Jonathan Shen, Fei Ren, Patrick Nguyen, Ruoming Pang, Ignacio Lopez Moreno, Yonghui Wu, et al. Transfer learning from speaker verification to multispeaker text-to-speech synthesis. In Advances in neural information processing systems, pp. 4480–4490, 2018. ",
+        "bbox": [
+            174,
+            476,
+            826,
+            531
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jaehyeon Kim, Sungwon Kim, Jungil Kong, and Sungroh Yoon. Glow-tts: A generative flow for text-to-speech via monotonic alignment search. arXiv preprint arXiv:2005.11129, 2020. ",
+        "bbox": [
+            169,
+            540,
+            823,
+            569
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zvi Kons, Slava Shechtman, Alex Sorin, Carmel Rabinovitz, and Ron Hoory. High quality, lightweight and adaptable tts using lpcnet. arXiv preprint arXiv:1905.00590, 2019. ",
+        "bbox": [
+            169,
+            577,
+            823,
+            607
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kundan Kumar, Rithesh Kumar, Thibault de Boissiere, Lucas Gestin, Wei Zhen Teoh, Jose Sotelo, Alexandre de Brébisson, Yoshua Bengio, and Aaron C Courville. Melgan: Generative adversarial networks for conditional waveform synthesis. In Advances in Neural Information Processing Systems, pp. 14910–14921, 2019. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            670
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chao Li, Xiaokong Ma, Bing Jiang, Xiangang Li, Xuewei Zhang, Xiao Liu, Ying Cao, Ajay Kannan, and Zhenyao Zhu. Deep speaker: an end-to-end neural speaker embedding system. arXiv preprint arXiv:1705.02304, 2017. ",
+        "bbox": [
+            173,
+            678,
+            825,
+            720
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Renqian Luo, Xu Tan, Rui Wang, Tao Qin, Jinzhu Li, Sheng Zhao, Enhong Chen, and Tie-Yan Liu. Lightspeech: Lightweight and fast text to speech with neural architecture search. In 2021 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 2021. ",
+        "bbox": [
+            174,
+            728,
+            826,
+            772
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of machine learning research, 9(Nov):2579–2605, 2008. ",
+        "bbox": [
+            171,
+            780,
+            823,
+            809
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael McAuliffe, Michaela Socolof, Sarah Mihuc, Michael Wagner, and Morgan Sonderegger. Montreal forced aligner: Trainable text-speech alignment using kaldi. In Interspeech, pp. 498–502, 2017. ",
+        "bbox": [
+            173,
+            816,
+            826,
+            859
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Henry B Moss, Vatsal Aggarwal, Nishant Prateek, Javier González, and Roberto Barra-Chicote. Boffin tts: Few-shot speaker adaptation by bayesian optimization. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 7639–7643. IEEE, 2020. ",
+        "bbox": [
+            174,
+            867,
+            826,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Vassil Panayotov, Guoguo Chen, Daniel Povey, and Sanjeev Khudanpur. Librispeech: an asr corpus based on public domain audio books. In 2015 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 5206–5210. IEEE, 2015. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kainan Peng, Wei Ping, Zhao Song, and Kexin Zhao. Non-autoregressive neural text-to-speech. ICML, 2020. ",
+        "bbox": [
+            173,
+            155,
+            825,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wei Ping, Kainan Peng, Andrew Gibiansky, Sercan O. Arik, Ajay Kannan, Sharan Narang, Jonathan Raiman, and John Miller. Deep voice 3: 2000-speaker neural text-to-speech. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            176,
+            193,
+            823,
+            234
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yi Ren, Yangjun Ruan, Xu Tan, Tao Qin, Sheng Zhao, Zhou Zhao, and Tie-Yan Liu. Fastspeech: Fast, robust and controllable text to speech. In NeurIPS, 2019. ",
+        "bbox": [
+            173,
+            243,
+            825,
+            272
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yi Ren, Chenxu Hu, Xu Tan, Tao Qin, Sheng Zhao, Zhou Zhao, and Tie-Yan Liu. Fastspeech 2: Fast and high-quality end-to-end text-to-speech. In ICLR, 2021. ",
+        "bbox": [
+            174,
+            281,
+            823,
+            310
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Shen, Ruoming Pang, Ron J Weiss, Mike Schuster, Navdeep Jaitly, Zongheng Yang, Zhifeng Chen, Yu Zhang, Yuxuan Wang, Rj Skerrv-Ryan, et al. Natural tts synthesis by conditioning wavenet on mel spectrogram predictions. In 2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 4779–4783. IEEE, 2018. ",
+        "bbox": [
+            173,
+            319,
+            826,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guangzhi Sun, Yu Zhang, Ron J Weiss, Yuan Cao, Heiga Zen, Andrew Rosenberg, Bhuvana Ramabhadran, and Yonghui Wu. Generating diverse and natural text-to-speech samples using a quantized fine-grained vae and autoregressive prosody prior. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6699–6703. IEEE, 2020. ",
+        "bbox": [
+            173,
+            385,
+            826,
+            441
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hao Sun, Xu Tan, Jun-Wei Gan, Hongzhi Liu, Sheng Zhao, Tao Qin, and Tie-Yan Liu. Token-level ensemble distillation for grapheme-to-phoneme conversion. In INTERSPEECH, 2019. ",
+        "bbox": [
+            173,
+            450,
+            823,
+            479
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017. ",
+        "bbox": [
+            176,
+            488,
+            823,
+            531
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christophe Veaux, Junichi Yamagishi, Kirsten MacDonald, et al. Superseded-cstr vctk corpus: English multi-speaker corpus for cstr voice cloning toolkit. 2016. ",
+        "bbox": [
+            169,
+            540,
+            825,
+            569
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Li Wan, Quan Wang, Alan Papir, and Ignacio Lopez Moreno. Generalized end-to-end loss for speaker verification. In 2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 4879–4883. IEEE, 2018. ",
+        "bbox": [
+            176,
+            577,
+            823,
+            619
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuxuan Wang, RJ Skerry-Ryan, Daisy Stanton, Yonghui Wu, Ron J Weiss, Navdeep Jaitly, Zongheng Yang, Ying Xiao, Zhifeng Chen, Samy Bengio, et al. Tacotron: Towards end-to-end speech synthesis. arXiv preprint arXiv:1703.10135, 2017. ",
+        "bbox": [
+            176,
+            628,
+            823,
+            672
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuzi Yan, Xu Tan, Bohan Li, Tao Qin, Sheng Zhao, Yuan Shen, and Tie-Yan Liu. Adaspeech 2: Adaptive text to speech with untranscribed data. In 2021 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 2021. ",
+        "bbox": [
+            176,
+            680,
+            823,
+            723
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Heiga Zen, Viet Dang, Rob Clark, Yu Zhang, Ron J Weiss, Ye Jia, Zhifeng Chen, and Yonghui Wu. Libritts: A corpus derived from librispeech for text-to-speech. arXiv preprint arXiv:1904.02882, 2019. ",
+        "bbox": [
+            173,
+            732,
+            826,
+            775
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhen Zeng, Jianzong Wang, Ning Cheng, and Jing Xiao. Prosody learning mechanism for speech synthesis system without text length limit. arXiv preprint arXiv:2008.05656, 2020. ",
+        "bbox": [
+            171,
+            784,
+            823,
+            813
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chen Zhang, Yi Ren, Xu Tan, Jinglin Liu, Kejun Zhang, Tao Qin, Sheng Zhao, and Tie-Yan Liu. Denoispeech: Denoising text to speech with frame-level noise modeling. In 2021 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 2021. ",
+        "bbox": [
+            174,
+            820,
+            825,
+            864
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zewang Zhang, Qiao Tian, Heng Lu, Ling-Hui Chen, and Shan Liu. Adadurian: Few-shot adaptation for neural text-to-speech with durian. arXiv preprint arXiv:2005.05642, 2020. ",
+        "bbox": [
+            174,
+            873,
+            823,
+            901
+        ],
+        "page_idx": 9
+    }
+]

parse/train/HJGv1Z-AW/HJGv1Z-AW.md

@@ -0,0 +1,263 @@
+# EMERGENCE OF LINGUISTIC COMMUNICATION FROM REFERENTIAL GAMES WITH SYMBOLIC AND PIXEL INPUT
+
+Angeliki Lazaridou∗, Karl Moritz Hermann, Karl Tuyls, Stephen Clark   
+DeepMind,   
+London, UK
+
+# ABSTRACT
+
+The ability of algorithms to evolve or learn (compositional) communication protocols has traditionally been studied in the language evolution literature through the use of emergent communication tasks. Here we scale up this research by using contemporary deep learning methods and by training reinforcement-learning neural network agents on referential communication games. We extend previous work, in which agents were trained in symbolic environments, by developing agents which are able to learn from raw pixel data, a more challenging and realistic input representation. We find that the degree of structure found in the input data affects the nature of the emerged protocols, and thereby corroborate the hypothesis that structured compositional language is most likely to emerge when agents perceive the world as being structured.
+
+# 1 INTRODUCTION
+
+The study of emergent communication is important for two related problems in language development, both human and artificial: language evolution, the development of communication protocols from scratch (Nowak & Krakauer, 1999); and language acquisition, the ability of an embodied agent to learn an existing language. In this paper we focus on the problem of how environmental or pre-linguistic conditions affect the nature of the communication protocol that an agent learns. The increasing realism and complexity of environments being used for grounded language learning (Brockman et al., 2016; Hermann et al., 2017) present an opportunity to analyse these effects in detail.
+
+In line with previous work on emergent communication, we are strongly motivated by the view that language derives meaning from its use (Wittgenstein, 1953; Wagner et al., 2003). This perspective especially motivates the study of language emergence in cases where co-operative agents try to achieve shared goals in game scenarios (Steels, 2003; Brighton & Kirby, 2006; Mordatch & Abbeel, 2017), and is related to the study of multi-agent and self-play methods that have found great success in other areas of machine learning (Bansal et al., 2017; Silver et al., 2017). Here we focus on simple referential games, in which one agent must communicate to another a target object in the agent’s environment.
+
+One of the most important properties of natural language is compositionality. Smaller building blocks (e.g. words, morphemes) are used to generate unbounded numbers of more complex forms (e.g. sentences, multi-word expressions), with the meaning of the larger form being determined by the meanings of its parts and how they are put together (Frege, 1892). Compositionality is an advantage in any communication protocol as it allows in principle infinite expression through a finite dictionary and a finite set of combination rules. In emergent communication research, previous work has shown that agents can produce (somewhat) compositional protocols when engaging in language games (Steels, 2003). However, the computational agents were typically situated in artificial worlds containing just a handful of objects, represented as disentangled, structured, and sometimes even atomic symbols, e.g. attribute-based or one-hot vectors (Batali, 1998; Brighton, 2002; Franke, 2015; Andreas & Klein, 2017; Mordatch & Abbeel, 2017). However, humans receive raw sensorimotor rather than symbolic input, and little work to date has tested whether these findings carry over when agents are situated in less idealized worlds that bear more similarity to the kind of entangled and noisy environments to which humans are typically exposed.1
+
+![](images/aea3a2fceb920cffdae0270c243ac52b72776e4d05ae8e6a4c4b0000f5f4d17a.jpg)  
+Figure 1: High-level overview of the referential game.
+
+In this work, in the context of referential communication games (see Figure 1), we contrast the results of two studies that lie at the extremes of how much structure is provided by the environment. The first study (Section 3) focuses on symbolic representations, where objects are represented as bags-of-attributes; this representation is inherently disentangled since dimensions encode individual properties. The second study (Section 4) considers raw perceptual input, hence data that more closely resembles what humans are exposed to. Clearly, the latter is a more challenging and realistic scenario as the computational agents are operating on entangled inputs with no pre-coded semantics. Crucially, both studies use the same referential game setup, the same learning procedure (policy learning methods) and the same neural network agent architectures.
+
+We show that reinforcement learning agents can successfully communicate, not only when presented with symbolic and highly structured input data, but (and more importantly) even when presented with raw pixel input. This result opens up the possibility of more realistic simulations of language emergence. We successfully use the learning signal from the referential game to train agents end-to-end, including cases where the agents need to perform visual processing of images with a convolutional neural network. However, we find that the agents struggle to produce structured messages when presented with entangled input data (Bengio et al., 2013) due to the difficulty of uncovering the true factors of variation, corroborating the hypothesis of Smith et al. (2003) that structured (compositional) language is most likely to emerge when agents perceive the world as structured.
+
+# 2 REFERENTIAL GAMES AS MULTI-AGENT CO-OPERATIVEREINFORCEMENT LEARNING
+
+The referential game is implemented as an instance of multi-agent co-operative reinforcement learning, in which two agents take discrete actions in their environment in order to maximize a shared reward.
+
+# 2.1 GAME AND TERMINOLOGY
+
+The referential game is a variant of the Lewis signaling game (Lewis, 1969), which has been extensively used in linguistic and cognitive studies in the context of language evolution (e.g., Briscoe, 2002; Cangelosi & Parisi, 2002; Steels & Loetzsch, 2012; Spike et al., 2016; Lazaridou et al., 2017).
+
+Figure 1 provides a schematic description of our setup. First, a speaker is presented with a target object (highlighted as CAR in the symbolic example on the left, and highlighted as the far right image in the pixel example on the right). Then, by making use of an alphabet consisting of primitive discrete symbols $( ^ { \ast \cdot } 2 2 ^ { \cdot \prime } , ^ { \cdot \cdot } 1 0 ^ { \cdot \prime } , ^ { \cdot \cdot } 0 ^ { \cdot \prime } , ^ { \cdot \cdot } 2 ^ { \cdot \prime } )$ , the speaker constructs a message describing that object (“22 $2 0 ^ { \circ } )$ . We will refer to the set of all distinct messages generated by the speaker as their lexicon or protocol. Finally, the listener is presented with the target and a set of distractor objects, and—by making use of the speaker’s message—has to identify the target object from the set of candidate objects. Communicative success is defined as the correct identification of the target by the listening agent.
+
+Formally, the attribute-based object vectors (disentangled) or the pixel-based images (entangled) are the set of pre-linguistic items $W = \{ o _ { 1 } , \ldots , o _ { N } \}$ . From this set we draw a target $t \in W$ and subsequently $K - 1$ distractors $D = \{ d _ { 1 } , \dots , d _ { K - 1 } \} \subset W$ s.t. ∀j $t \neq d _ { j }$ . The speaker has only access to the target $t$ , while the listener receives candidate set $C = t \cup D$ , not knowing which of the elements in $C$ is target $t$ .
+
+# 2.2 AGENTS
+
+The speaker encodes $t$ into a dense representation $u$ using an encoder $f ^ { S } ( t , \theta _ { f } ^ { S } )$ . The function of this encoder depends on the type of pre-linguistic data used and is discussed separately for each study. Given an alphabet $A$ of discrete unit symbols (akin to words) and $u$ , the speaker next generates a discrete, variable-length, bounded message m by sampling symbols from a recurrent policy $\pi ^ { S }$ defined by a decoder $\check { g } ^ { S } ( u , \theta _ { g } ^ { S } )$ . The sequence generation is terminated either by the production of a stop symbol or when the maximum length $L$ has been reached. We implement the decoder as a single-layer LSTM (Hochreiter $\&$ Schmidhuber, 1997). Note that the symbols in the agents’ alphabet $A$ have no a priori meaning; rather, these symbols get grounded during the game.
+
+The listening agent uses a similar encoder to the speaker but has independent network weights $( \theta _ { f } ^ { L } )$ . Applying this encoder to all candidate objects results in a set $U = \{ f ^ { L } ( c , \theta _ { f } ^ { L } ) \mid c \in C \}$ . For encoding the message $\mathbf { m }$ , we use a single-layer LSTM, denoted $h ^ { L }$ , which produces an encoding $z$ : $z = h ^ { L } ( \mathbf { \bar { m } } , \theta _ { h } ^ { L } )$ .
+
+Given encoded message $z$ and candidates $U$ , the listener predicts a target object $t ^ { \prime } \in C$ following a policy $\pi ^ { L }$ implemented using a non-parametric pointing module; this module samples the predicted object from a Gibbs distribution computed via the dot product between vector $z$ and all encoded candidates $u \in U$ . See Appendix B for information regarding the agents’ architecture.
+
+At inference time, we replace the stochastic sampling of the speaker’s message and the listener’s stochastic pointing module with deterministic processes. For the pointing module, the object with the highest probability is chosen. For the speaker’s message, this is generated in a greedy fashion by selecting the highest-probability symbol at each step.
+
+# 2.3 LEARNING
+
+All weights of the speaker and listener agents, $\theta = \{ \theta _ { f } ^ { S } , \theta _ { g } ^ { S } , \theta _ { f } ^ { L } , \theta _ { h } ^ { L } \}$ , are jointly optimized while playing the game. We emphasize that no weights are shared between the speaker and the listener, and the only supervision used is communicative success, i.e. whether the listener identified the correct target. The objective function that the two agents maximize for one training instance is:
+
+$$
+R ( t ^ { \prime } ) \left( \sum _ { l = 1 } ^ { L } \log p ( m _ { t } ^ { l } | m _ { t } ^ { < l } , u ) + \log p ( u _ { t ^ { \prime } } | z , U ) \right)
+$$
+
+where $R$ is the reward function returning 1 if $t = t ^ { \prime }$ (if the listener pointed to the correct target) and 0 otherwise. To maintain exploration in the speaker’s policy $\pi ^ { S }$ of generating a message, and the listener’s policy $\pi ^ { L }$ of pointing to the target, we add to the loss an entropy regularization term (Mnih et al., 2016). The parameters are estimated using the REINFORCE update rule (Williams, 1992). See Appendix $\mathbf { B }$ for more details regarding the learning.
+
+<table><tr><td>max length</td><td>alphabet size</td><td>lexicon size</td><td>training accuracy</td><td>topographic p</td></tr><tr><td>2</td><td>10</td><td>31</td><td>92.0%</td><td>0.13</td></tr><tr><td>5</td><td>17</td><td>293</td><td>98.2%</td><td>0.16</td></tr><tr><td>10</td><td>40</td><td>355</td><td>98.5%</td><td>0.26</td></tr></table>
+
+Table 1: Commumicative success (training accuracy in percentage) with varying maximum message length. alphabet size denotes the effective size of the symbol set used from a maximum of 100. lexicon size is the effective number of unique messages used. topographic $\rho$ reports the structural similarity in terms of Spearman $\rho$ correlation between the message and the object vector space. All Spearman $\rho$ correlations throughout the paper are significant with $p < 0 . 0 1$ .
+
+# 3 STUDY 1: REFERENTIAL GAME WITH SYMBOLIC DATA
+
+We first present experiments where agents are learning to communicate when presented with structured and disentangled input. We use the Visual Attributes for Concepts Dataset (VisA) of Silberer et al. (2013), which contains human-generated per-concept attribute annotations for 500 concrete concepts (e.g., cat, sofa, car) spanning across different categories (e.g., mammals, furniture, vehicles), annotated with 636 general attributes (e.g., has tail, is black, has wheels). We disregarded homonym concepts (e.g., bat), thus reducing our working set of concepts to 463 and the number of attributes to 573 (after eliminating any attribute that did not occur with the working concepts). On average, each concept has 11 attributes. All pre-linguistic objects are represented in terms of binary vectors $o \in \{ 0 , 1 \} ^ { 5 7 3 }$ . Note that these representations do carry some inherent structure; the dimensions in the object vectors are disentangled and so each object can be seen as a conjunction of properties. Speaker and listener convert the pre-linguistic representations to dense representations $u$ by using a single-layer MLP with a sigmoid activation function.
+
+In all experiments, we set the number of candidate objects $K$ to five, meaning there were four wrong choices per correct one (resulting in a $2 0 \%$ random baseline). Inspired by Kottur et al. (2017), who show that non-compositional language emerges in the case of overcomplete alphabets, we set the size of alphabet $A$ to 100 symbols, which is smaller than the size of the set of objects (463).
+
+# 3.1 AGENT PERFORMANCE AND AMBIGUITY
+
+We first report model performance on the training data, comparing different settings for the maximal allowed message length (2, 5 or 10 symbols). Results are presented in Table 1 (ignore the last row topographic $\rho$ which will be explained in later sections).
+
+In the case of the shortest message settings (maximum length 2), our trained agents on average only develop a protocol of 31 unique messages used to describe 363 training concepts (leaving aside 100 for testing). This indicates high levels of ambiguity, with each message being used to denote 11 concepts on average. Interestingly, recent findings suggest that ambiguity is a design feature of language that prevents the inefficient use of redundant codes, since some of the message content can be extracted from context: “the most efficient communication system will not convey information already provided by the context” (Piantadosi et al., 2012). In our case, we do no explicitly encode any bias towards ambiguity. We hypothesize that ambiguity arises due to the difficult exploration problem that agents are faced with, in combination with the fact that ambiguous protocols present a good local optimum that is over-represented in the hypothesis search space. As a result, in the absence of environmental pressures (e.g., a high number of carefully constructed distractors) a suboptimal policy can still achieve a reasonably high accuracy $( 9 2 \% )$ , making it even harder during training to escape from such a solution.
+
+In classic signaling games, this polysemy phenomenon manifests itself as different states receiving the same signal and is termed partial pooling equilibrium (Skyrms, 2010). Perhaps rather counterintuitively, Skyrms (p.131) suggests that a way to obtain communication protocols that are robust to this type of local communication minima is to allow the invention of new signals, essentially increasing the search space of signals. Motivated by this suggestion, we play variants of the game in which we allow the agents to produce messages of greater maximum length (5 and 10), which leads to improved communicative success $9 8 . 2 \%$ and $9 8 . 5 \%$ respectively). We observe that the number of messages in the protocol increases from 31 to 293 and 355, respectively, reducing the average number of concepts a message can denote from 11 concepts to (approximately) 1 concept.
+
+![](images/f54b6c616adb9b6e25c20297338305d82c03c1c6cbacf39ded5809edadfd7eb1.jpg)  
+Figure 2: Training curves of different experimental setups with uniform and context-dependent target selection.
+
+# 3.2 REALISTIC CONTEXT DISTRIBUTION
+
+In the real world, when speakers refer to cats, listeners would likely be in a situation where they had to discriminate a cat in the context of a couch or a dog, rather than in the context of a mirror or a cow.2 Simply put, objects in the world do not appear in random contexts, but rather there is regularity in the distribution of situational and visual co-occurrences. This property of the world is typically not captured in referential games studied in the language emergence literature, with distractors usually drawn from a uniform distribution.
+
+We address this issue and design an additional experiment with distractors sampled from a targetspecific context distribution reflecting normalized object co-occurrence statistics. Co-occurrence data is extracted from the MSCOCO caption dataset (Lin et al., 2014). This leads to more plausible distractor sets with, for instance, the target goat more likely being mixed with sheep and cow as distractors rather than bike or eggplant.
+
+We find that the distractor selection process (uniform vs context-dependent) affects the language learning dynamics; see Figure 2 for training curves for different experimental configurations. While the non-uniform distractor sampling of the context-dependent setting can be exploited to learn a degenerate strategy —giving up to $40 \%$ communicative success shortly after the start of training— subsequently learning under this scenario takes longer. This effect is likely a combination of the local minimum achieved by the degenerate strategy of picking a target at random from only the topically relevant set of distractors, which initially makes the problem easier; however, the fact that the co-occurrence statistics tend to align with the feature vectors, means that similar objects are more likely to appear as distractors and hence the overall game becomes more difficult.
+
+We now consider the question of how objects denoted by the same (ambiguous) message are related. When the context is drawn uniformly, object similarity is a predictor of object confusability, as similar objects tend to be mapped onto the same message (0.26 and 0.43 median pairwise cosine similarities of objects that received the same message as computed on the VisA space, for maximum message length 2 and 5, respectively). In the non-uniform case, we observe object confusability to be less influenced by object similarity (0.15 and 0.17 median pairwise cosine similarities of objects that received the same message, for maximum message length 2 and 5, respectively), but rather driven by the visual context co-occurrences. Simply put, in the non-uniform case confusability is less influenced by similarity since the agents must learn to distinguish between objects that naturally co-occur (e.g. sheep and goat). Thus, the choice of distractors, an experimental design decision that in existing language emergence literature has been neglected, has an effect on the organization (and potentially the naturalness) of the emerged language, for example as reflected in the semantics of ambiguous or homonym words in the language.
+
+Table 2: Communicative success (acc in percentage) of agents evaluated on training (first row) and novel (last three rows) data. lexicon size column reports the percentage of novel messages (i.e., messages that were not used during the training).   
+
+<table><tr><td>Data</td><td>length 2 lexicon size</td><td>acc.</td><td>length 5 lexicon size</td><td>acc.</td><td>length 10 lexicon size</td><td>acc.</td></tr><tr><td>training data</td><td>31</td><td>92.0</td><td>293</td><td>98.2</td><td>355</td><td>98.5</td></tr><tr><td>test data</td><td>1</td><td>74.2</td><td>70</td><td>76.8</td><td>98</td><td>81.6</td></tr><tr><td>unigram chimera</td><td>5</td><td>39.3</td><td>88</td><td>40.5</td><td>99</td><td>47.0</td></tr><tr><td>uniform chimera</td><td>3</td><td>31.2</td><td>87</td><td>32.2</td><td>100</td><td>42.6</td></tr></table>
+
+# 3.3 STRUCTURAL PROPERTIES OF EMERGED PROTOCOLS
+
+Quantifying the degree of compositionality and structure found in the emerged language is a challenging task; to the best of our knowledge, there is no formal mathematical definition of compositionality that would allow for a definitive quantitative measure. Thus, research on this topic usually relies on defining necessary requirements that any language claiming to be compositional should adhere to, such as the ability to generalize to novel situations (Batali, 1998; Franke, 2015; Kottur et al., 2017). We adopt a similar strategy by measuring the extent to which an emerged language is able to generalize to novel objects (Section 3.3.1). Moreover, we also report quantitative results (Section 3.3.2) using a measure of message structure proposed in the language evolution literature (Brighton & Kirby, 2006; Carr et al., 2017).
+
+# 3.3.1 GENERALIZATION TO NOVEL OBJECTS
+
+We perform experiments where trained agents from Section 3.1 are exposed to different types of unseen objects, each of them differing to the degree to which the unseen objects resemble the objects found in the training data. In the test scenario, objects come from the same data distribution as the training data, but were not presented to the agents during training (e.g., a mouse); in the unigram chimeras scenario, the novel objects are constructed by sampling properties from a property-based distribution inferred from the training data, thus breaking any feature correlation (e.g., a mouselike animal with wheels); in the uniform chimeras scenario, the novel objects are constructed by uniformly sampling properties (e.g., a square red furry metallic object).
+
+Table 2 reports the communicative success. While there is a drop in performance for unseen objects, agents are performing above random chance $( 2 0 \% )$ . The emerged language is indeed able to generalize to unseen objects; however, the degree of generalization is a function of the similarity between the training and unseen objects, thus resulting in the uniform chimeras setting obtaining the lowest performance.
+
+Moreover, we observe examples of productivity, a key feature of compositionality. At test time, speakers are able to concoct novel messages on-the-fly (i.e., messages that are not part of their lexicon induced during training) to describe unseen objects. See the last three rows of Table 2, and the lexicon size column, for the percentage of novel messages. Even though listeners were not trained to associate novel messages with novel objects, they are still able comprehend such messages and correctly identify the target object. In the test data and length 10 cases, novel messages account for almost all of the generated messages, but with performance at $8 1 . 6 \%$ , providing evidence of the structure found in the messages.
+
+# 3.3.2 TOPOGRAPHIC SIMILARITY
+
+Given a set of objects, their meanings and the associated signals, Brighton & Kirby (2006) define topographic similarity to be the correlation of the distances between all the possible pairs of meanings and the corresponding pairs of signals. Figure 3 shows mappings between states and signals for examples of holistic (b) and compositional (c,d) languages, with the topographic similarity of compositional languages being higher than that of holistic. The intuition behind this measure is that semantically similar objects should have similar messages.
+
+![](images/cd5d57f50366fee02fe1b3ce12b993334e48d59f130b088d0fbe530764268416.jpg)  
+Figure 3: left: Three languages with different properties, taken from Brighton & Kirby (2006). The mapping between states and signals shown in (b) is random; there is no relationship between points in the meaning and signal space. In (c) and (d), similar meanings map to similar signals, i.e., there is a topographic relation between meanings and signals. right: Relation between objects’ cosine similarity and their message Levenshtein distance for trained and random agents.
+
+To compute this measure, we first compute two lists of numbers: (i) the Levenshtein distances between all pairs of objects’ messages; and (ii) the cosine similarity between all pairs of objects’ VisA vectors. Given these two lists, the topographic similarity is defined as their negative Spearman $\rho$ correlation (since we are correlating distances with similarities, negative values of correlation indicate topographic similarity of the two spaces). Intuitively, if similar objects share much of the message structure (e.g., common prefixes or suffixes), and dissimilar objects have little common structure in their respective messages, then the topographic similarity should be high, the highest possible value being 1.
+
+Results presented back in Table 1, in the topographic $\rho$ column, show that topographic similarity is positive in all experimental setups, indicating that similar objects receive similar messages $( p < 0 . 0 1$ , permutation test). A qualitative analysis of the messages generated in the length 10 and training data cases showed that, for example, $32 \%$ of the mammal objects had as a message prefix the bigram $9 5 \# 1 0 ^ { \star }$ ; $36 \%$ of vehicle objects had $\cdot 6 8 \# 9 5 $ ; and $11 \%$ of tool objects had ‘0#61’, suggesting that these prefix bigrams encode category-specific information.
+
+Next, for each object pair, we calculate their Levenshtein message distance and respective cosine similarity, and plot in Figure 3 (right), for each distance, the average cosine similarities of the pairs with that distance (this is done for the length 10 and training data experiment). We observe that there is a clear relation between message similarity and meaning similarity (as measured by overlap in the VisA properties). In Figure 3, we also plot a similar correlation curve for an emerged language obtained by producing messages with randomly initialized and untrained speaker/listener architectures. This emerged language is at random in terms of communicative success; however, the generated messages do show signs of structure, since similar objects obtain somewhat similar messages. This seems to suggest that structured and disentangled pre-linguistic representations are, perhaps, a sufficient condition for the emergence of structured language, especially in neural network-based agents which, due to the nature of representation and information flow, favor similar inputs to trigger similar outputs.
+
+# 4 STUDY 2: REFERENTIAL GAME WITH RAW PIXEL DATA
+
+In this section, we present experiments in which agents receive as input entangled data in the form of raw pixel input, and have to learn to perform visual conceptual processing guided by the communication-based reward.
+
+We use a synthetic dataset of scenes consisting of geometric objects generated using the MuJoCo physics engine (Todorov et al., 2012). We generate RGB images of resolution $1 2 4 \times 1 2 4$ depicting single object scenes. For each object, we pick one of eight colors (blue, red, white, black, yellow, green, cyan, magenta) and five shapes (box, sphere, cylinder, capsule, ellipsoid) resulting in 40 combinations, for each of which we generate 100 variations, varying the floor color and the object location in the image. Moreover, we introduce different variants of the game: game A with 19 distractors; game B with 1 distractor; game C with 1 distractor, and with speaker and listener having different viewpoints of the target object (the target object on the listener’s side is in a different location); game D with 1 distractor, with speaker and listener having different viewpoints, and with balanced numbers of shapes and color (obtained by downsampling from 8 colors to 5 and removing any image containing objects of the 3 disregarded objects). For each game, we create train and test splits with proportions 75/25 (i.e., 3000/1000 for games A and B, and 1850/650 for games C and D).
+
+Pre-linguistic objects are presented in the form of pixel input, $o \in [ 0 , 2 5 5 ] ^ { 3 \times 1 2 4 \times 1 2 4 }$ . Speaker and listener convert the images $o$ to dense representations $u$ , each of them using an 8-layer convolutional neural network (ConvNet). Crucially, we do not pre-train the ConvNets on an object classification task; the only learning signal is the communication-based reward. Despite this fact, we observe that the lower layers of the ConvNets are encoding similar information to a ConvNet pre-trained on ImageNet (Deng et al., 2009).3 Conceptually, we can think of the whole speaker/listener architecture as an encoder-decoder with a discrete bottleneck (the message). Given our initial positive findings, this reward-based learning signal induced from the communication game setup could be used for classagnostic large-scale ConvNet training. Moreover, we find that, even though no weights were shared, the agents’ conceptual spaces get aligned at different levels, reminiscent of theories of interactive conceptual alignment during dialogue (Garrod & Pickering, 2004) (see Appendix A for the related experiment).
+
+# 4.1 COMMUNICATIVE SUCCESS AND EMERGENT PROTOCOLS
+
+Unlike the experiments of Section 3, where agents start from disentangled representations, starting from raw perceptual input presents a greater challenge: the agents have to establish naming conventions about scenes, while at the same time learning to process the input with their own visual conceptual system. Since we do not pre-train their ConvNets on an object recognition task, the dense representations $u$ used to derive the message contain no bias towards any image- or scene-specific information (e.g, object color, shape or location). The extraction of visual properties is thus driven entirely by the communication game. This contrasts with the cases of Havrylov & Titov (2017) and Lazaridou et al. (2017) who use pre-trained visual vectors, and qualitatively observe that the induced communication protocols encode information about objects. Table 3 presents the results in terms of communicative train and test success (see Appendix C for additional experiments when having access to gold object attribute classifiers). Moreover, we also report the topographic similarity (column topographic $\rho \mathrm { \Sigma }$ ) between the symbolic attribute-based representations of scenes (floor color, object color, shape and location) and the generated messages.
+
+Overall, despite the challenges posed in this setup due to the raw nature of the data, performance across all games is well above chance, indicating that reinforcement learning agents trained end-toend are able to establish a communication protocol in this grounded environment. In game A, the agents reach $9 3 . 7 \%$ accuracy, with their lexicon consisting of 1068 messages, describing 3000 training objects. Most importantly, as captured by the positive topographic similarity, agents produce messages that respect (even to a limited degree) the compositional nature of scenes (i.e., objects as bags-of-attributes), indicating that similar scenes receive similar messages. Indeed, by examining their protocol (see Table 4), we find that messages encode in a structurally consistent way information about absolute location of objects, with the message prefix and suffix denoting the horizontal and vertical co-ordinate, respectively. Interestingly, this communication strategy is also typically followed by human players of referential games (Kazemzadeh et al., 2014).
+
+![](images/1a48df6cd3a8b1c8b52b9ee8420e381abf4d505b03645f3a5586570289a52a63.jpg)  
+Figure 4: Target images and their associated messages from game A and game B.
+
+Table 3: Communicative success of agents playing different games. Columns random, train and test report percentage accuracies. Column topographic $\rho$ reports the topographic similarity between the symbolic representation of scenes and the generated messages $( p < 0 . 0 1$ , permutation test).   
+
+<table><tr><td>game</td><td>distractors</td><td>balanced</td><td>viewpoints</td><td>lexicon size</td><td>random</td><td>train</td><td>test</td><td>topographic p</td></tr><tr><td>A</td><td>20</td><td>No</td><td>No</td><td>1068</td><td>5.0</td><td>93.7</td><td>93.6</td><td>0.13</td></tr><tr><td>B</td><td>2</td><td>No</td><td>No</td><td>13</td><td>50.0</td><td>93.2</td><td>93.4</td><td>0.006</td></tr><tr><td>C</td><td>2</td><td>No</td><td>Yes</td><td>8</td><td>50.0</td><td>86.0</td><td>85.7</td><td>0.07</td></tr><tr><td>D</td><td>2</td><td>Yes</td><td>Yes</td><td>5</td><td>50.0</td><td>90.4</td><td>89.9</td><td>0.06</td></tr></table>
+
+However, we find the emerged protocols to be very unstable and too grounded in the specific game situation. Small modifications of the game setup, while having close to no negative impact on the communicative performance, can radically alter the form, semantics and interpretability of the communication protocol. In game B, performance remains at the same level $( 9 3 . 2 \% )$ as game A. However, we observe that the protocol consists of 13 unique messages which do not reflect the objects’ attributes (as indicated by the close to zero topographic similarity), thus making the messages harder to interpret (see Figure 4 for randomly sampled examples). When we change the viewpoint of the agents in game C, biasing them against communicating about absolute object location, the players derive a compact communication protocol consisting of 8 unique messages that describe primarily color. Finally, when color and shape are balanced, as in game $\mathbf { D }$ , we still observe a bias towards describing the color of objects, with the five induced messages providing a perfect clustering of the objects according to their colors.4
+
+In an entangled world, agents do not possess a priori visual biases and knowledge of concepts. Since objects can be conceptualized in indefinitely many ways, the type of information encoded in the messages is tied to the environmental pressures; communication behaviour is a function of the environment, which also dictates what data structures can emerge. The implication of this observation is that protocols essentially overfit to the particular game situation, to the degree that they become specialized ad-hoc naming conventions.
+
+Interestingly, the emergence of ad-hoc naming conventions has also been observed during humanhuman interaction: when participants engage in some specific game situation (e.g., communicating about abstract tangram shapes), they tend to form highly specialized naming conceptions (conceptual pacts) that allow them to communicate with maximum efficiency (Brennan & Clark, 1996). While in this study we do not address the issue of how a stable and general language could emerge in entangled worlds, we believe that to alleviate the formation of such ad-hoc communication protocols, it is essential to increase the complexity of the games as well as requiring transfer across a variety of games.
+
+<table><tr><td>game (random baseline)</td><td>object position (20.0)</td><td>object shape (20.0)</td><td>object color (12.0)</td><td>floor color (33.0)</td></tr><tr><td>A</td><td>95.3</td><td>90.2</td><td>24.7</td><td>36.4</td></tr><tr><td>B</td><td>88.6</td><td>41.2</td><td>63.8</td><td>45.4</td></tr><tr><td>C</td><td>85.9</td><td>43.5</td><td>65.8</td><td>43.8</td></tr><tr><td>D</td><td>89.4</td><td>47.1</td><td>82.0</td><td>42.3</td></tr></table>
+
+Table 4: Accuracy of probe linear classifiers of speaker’s induced visual representations (all accuracies are in percentage format).
+
+# 4.2 PROBE MODELS
+
+In order to investigate what information gets captured by the speaker’s ConvNet, we probe the inferred visual representations $u$ used to derive the message. Specifically, we design 4 probe classifiers for the color and shape of the object; object position which is derived by discretizing each co-ordinate into 3 bins; and floor color which is obtained by clustering the RGB color representation of the floor. For each probe, we performed 5-fold cross validation with a linear classifier, and report accuracy results in Table 4. Overall, different games result in visual representations with different predictive power; object position is almost always encoded in the speaker’s visual representation, even in situations where location of the object is not a good strategy for communication. On the other hand, object shape seems to provide less salient information, despite the fact that it is relevant for communication, at least in the C&D games.
+
+As expected, the structure and semantics of the emergent protocols are a function of the information captured in the visual representations. The degree to which the agents are able to pull apart the objects’ factors of variation impacts their ability to communicate about those factors, with the most extreme case being game D, where the message ignores the shape entirely. Thus, disentanglement seems to be a necessary condition for communication, at least in the case of pixel input.
+
+# 5 CONCLUSION
+
+We presented a series of studies investigating the properties of protocols emerging when reinforcement learning agents are trained end-to-end on referential communication games. We found that when agents are presented with disentangled input data in the form of attribute vectors, this inherent compositional structure is successfully retained in the output. Moreover, we showed that communication can also be achieved in cases where agents are presented with raw pixel data, a type of input that aligns better with the raw sensorimotor data that humans are exposed to. At the same time, we found that their ability to form compositional protocols in these cases is hampered by their ability to pull apart the objects’ factors of variations. Altogether, we were able to successfully scale up traditional research from the language evolution literature on emergent communication tasks to the contemporary deep learning framework, thus opening avenues to more realistic, and large scale, computational simulations of language emergence with complex image stimuli.
+
+# ACKNOWLEDGEMENTS
+
+We would like to thank Murray Shanahan, Laura Rimell and Gabor Melis for their very helpful feedback on this paper, as well as the rest of the DeepMind language team for many discussions. AL would also like to thank Marco Baroni and Alex Peysakhovich for the email correspondence and discussions from a year ago, which provided inspiration for some of the experiments on this paper.
+
+# REFERENCES
+
+Jacob Andreas and Dan Klein. Analogs of linguistic structure in deep representations. arXiv preprint arXiv:1707.08139, 2017.
+
+Trapit Bansal, Jakub Pachocki, Szymon Sidor, Ilya Sutskever, and Igor Mordatch. Emergent complexity via multi-agent competition. arXiv preprint arXiv:1710.03748, 2017.
+
+John Batali. Computational simulations of the emergence of grammar. pp. 405–426, 1998.
+
+Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. IEEE transactions on pattern analysis and machine intelligence, 35(8):1798–1828, 2013.
+
+Susan E Brennan and Herbert H Clark. Conceptual pacts and lexical choice in conversation. Journal of Experimental Psychology: Learning, Memory, and Cognition, 22(6):1482, 1996.
+
+Henry Brighton. Compositional syntax from cultural transmission. Artificial life, 8(1):25–54, 2002.
+
+Henry Brighton and Simon Kirby. Understanding linguistic evolution by visualizing the emergence of topographic mappings. Artificial life, 12(2):229–242, 2006.
+
+Ted Briscoe (ed.). Linguistic evolution through language acquisition. Cambridge University Press, Cambridge, UK, 2002.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016.
+
+Angelo Cangelosi and Domenico Parisi (eds.). Simulating the evolution of language. Springer, New York, 2002.
+
+Jon W Carr, Kenny Smith, Hannah Cornish, and Simon Kirby. The cultural evolution of structured languages in an open-ended, continuous world. Cognitive science, 41(4):892–923, 2017.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. IEEE, 2009.
+
+Katrina Evtimova, Andrew Drozdov, Douwe Kiela, and Kyunghyun Cho. Emergent language in a multi-modal, multi-step referential game. arXiv preprint arXiv:1705.10369, 2017.
+
+Michael Franke. The evolution of compositionality in signaling games. Journal of Logic, Language and Information, pp. 1–23, 2015.
+
+Gottlob Frege. Uber Sinn und Bedeutung. ¨ Zeitschrift fur Philosophie und philosophische Kritik ¨ , 100:25–50, 1892.
+
+Simon Garrod and Martin J Pickering. Why is conversation so easy? Trends in cognitive sciences, 8(1):8–11, 2004.
+
+Serhii Havrylov and Ivan Titov. Emergence of language with multi-agent games: Learning to communicate with sequences of symbols. arXiv preprint arXiv:1705.11192, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Karl Moritz Hermann, Felix Hill, Simon Green, Fumin Wang, Ryan Faulkner, Hubert Soyer, David Szepesvari, Wojtek Czarnecki, Max Jaderberg, Denis Teplyashin, et al. Grounded language learning in a simulated 3d world. arXiv preprint arXiv:1706.06551, 2017.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Sahar Kazemzadeh, Vicente Ordonez, Mark Matten, and Tamara L Berg. Referitgame: Referring to objects in photographs of natural scenes. In EMNLP, pp. 787–798, 2014.
+
+Satwik Kottur, Jose MF Moura, Stefan Lee, and Dhruv Batra. Natural language does not ´ emerge’naturally’in multi-agent dialog. arXiv preprint arXiv:1706.08502, 2017.
+
+Angeliki Lazaridou, Alexander Peysakhovich, and Marco Baroni. Multi-agent cooperation and the emergence of (natural) language. In ICLR, 2017.
+
+David Lewis. Convention. Harvard University Press, Cambridge, MA, 1969.
+
+Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ European conference on computer vision, pp. 740–755. Springer, 2014.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning, pp. 1928–1937, 2016.
+
+Igor Mordatch and Pieter Abbeel. Emergence of grounded compositional language in multi-agent populations. arXiv preprint arXiv:1703.04908, 2017.
+
+Martin A Nowak and David C Krakauer. The evolution of language. Proceedings of the National Academy of Sciences, 96(14):8028–8033, 1999.
+
+Steven T Piantadosi, Harry Tily, and Edward Gibson. The communicative function of ambiguity in language. Cognition, 122(3):280–291, 2012.
+
+Carina Silberer, Vittorio Ferrari, and Mirella Lapata. Models of semantic representation with visual attributes. In Proceedings of the 51st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 572–582, Sofia, Bulgaria, August 2013. Association for Computational Linguistics. URL http://www.aclweb.org/anthology/P13-1056.
+
+David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, Yutian Chen, Timothy Lillicrap, Fan Hui, Laurent Sifre, George van den Driessche, Thore Graepel, and Demis Hassabis. Mastering the game of go without human knowledge. Nature, 550:354–359, 2017.
+
+Brian Skyrms. Signals: Evolution, learning, and information. Oxford University Press, 2010.
+
+Kenny Smith, Simon Kirby, and Henry Brighton. Iterated learning: A framework for the emergence of language. Artificial life, 9(4):371–386, 2003.
+
+Matthew Spike, Kevin Stadler, Simon Kirby, and Kenny Smith. Minimal requirements for the emergence of learned signaling. Cognitive Science, 2016. In press.
+
+Luc Steels. Social language learning. In Mario Tokoro and Luc Steels (eds.), The Future of Learning, pp. 133–162. IOS, Amsterdam, 2003.
+
+Luc Steels and Martin Loetzsch. The grounded naming game. In Luc Steels (ed.), Experiments in Cultural Language Evolution, pp. 41–59. John Benjamins, Amsterdam, 2012.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012.
+
+Kyle Wagner, James A Reggia, Juan Uriagereka, and Gerald S Wilkinson. Progress in the simulation of emergent communication and language. Adaptive Behavior, 11(1):37–69, 2003.
+
+Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Mach. Learn., 8(3-4):229–256, May 1992. ISSN 0885-6125. doi: 10.1007/ BF00992696. URL https://doi.org/10.1007/BF00992696.
+
+Ludwig Wittgenstein. Philosophical Investigations. Blackwell, Oxford, UK, 1953. Translated by G.E.M. Anscombe.
+
+# A CONCEPTUAL ALIGNMENT OF SPEAKER AND LISTENER
+
+During conversation, communication allows interlocutors to achieve interactive conceptual alignment (Garrod & Pickering, 2004). We are able to communicate because we have established a common ground and our representations at different levels become aligned (e.g., participants mutually understand that “he” in the conversation refers to Bob). We investigated whether the agents’ conceptual systems achieve a similar structural alignment. We measure the alignment in terms of Spearman $\rho$ correlation of the intra-agent pairwise object cosine similarities as calculated via representing objects as activations from ConvNet layers.
+
+Interestingly, we observe a gradual increase in the structural similarity as we represent the objects with layer activations closer to the pixel space. Conceptual spaces are more aligned the closer they are to the raw pixel input $\mathrm { ~ \ ' ~ } \rho = 0 . 9 7 \mathrm { - } 0 . 9 1$ , depending on the game) and become more dissimilar as the representations become more abstract. We can draw the analogy to language processing, as first ConvNet layers perform some low-level processing analogous to phoneme recognition or word segmentation (and are thus more objective) while higher layers perform more abstract processing, vaguely analogous to semantics and pragmatics (thus, represent more subjective knowledge). In cases of successful communication, speakers’ and listeners’ conceptual spaces closer to the communication point are structurally very similar $\prime \rho = 0 . 8 5 – 0 . 6 2$ , depending on the game), however this similarity drops dramatically in cases of failure of communication $\mathit { \Pi } _ { \rho } = 0 . 1 5 $ ).
+
+# B HYPERPARAMETER DETAILS
+
+All LSTM hidden states of the “speaking” and “listening” module as well and the “seeing” prelinguistic feed-forward encoders (see Section 3), have dimension 50. The “seeing” pre-linguistic ConvNet encoders (see Section 4) has 8 layers, 32 filters with the kernel size 3 for every layer and with strides $[ 2 , 1 , 1 , 2 , 1 , 2 , 1 , 2 ]$ for each layer. We use ReLU as activation function as well as batch normalization for every layer.
+
+For learning, we used the Rmsprop optimizer, with learning rate 0.0001. We use a separate value of entropy regularization for each policy. For $\pi ^ { S }$ we use 0.01 and for $\pi ^ { L }$ we use 0.001. We use a mini-batch of 32.
+
+# C COMMUNICATIVE SUCCESS USING GOLD ATTRIBUTE CLASSIFIERS
+
+We assume a model which has access to perfect attribute classifiers for color, shape and object position, for the latter using a classifier operating on the discretized annotations we obtained in Section 4.2 after quantazing the real-valued object location. For computing the performance of this model using gold attribute classifiers, we first remove from the distractors any candidate not matching the target’s attributes and them pick at random. We repeat this experiment for single attribute classifiers and their pairwise combinations. Table 5 reports the communicative success results obtained empirically by averaging across 1000 simulations, alongside the training and test accuracies of the trained agents of Section 4.1 for comparison.
+
+Table 5: Communicative success of trained models from Section 4.1 (train and test) as well as models with access to gold classifiers. All accuracies are in percentage format.   
+
+<table><tr><td> game</td><td>train</td><td>test</td><td>color</td><td>shape</td><td>position</td><td>color &amp; shape</td><td> position &amp; shape</td><td>position &amp; color</td></tr><tr><td>A</td><td>93.7</td><td>93.6</td><td>37.2</td><td>24.8</td><td>69.3</td><td>80.4</td><td>92.1</td><td>95.6</td></tr><tr><td>B</td><td>93.2</td><td>93.4</td><td>93.2</td><td>90.1</td><td>97.2</td><td>98.8</td><td>99.3</td><td>99.4</td></tr><tr><td>C</td><td>86.0</td><td>85.7</td><td>93.2</td><td>90.1</td><td>-</td><td>98.8</td><td>1</td><td>1</td></tr><tr><td>D</td><td>90.4</td><td>89.9</td><td>89.6</td><td>89.2</td><td>1</td><td>98.5</td><td>1</td><td>1</td></tr></table>

parse/train/HJGv1Z-AW/HJGv1Z-AW_content_list.json

@@ -0,0 +1,1473 @@
+[
+    {
+        "type": "text",
+        "text": "EMERGENCE OF LINGUISTIC COMMUNICATION FROM REFERENTIAL GAMES WITH SYMBOLIC AND PIXEL INPUT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Angeliki Lazaridou∗, Karl Moritz Hermann, Karl Tuyls, Stephen Clark   \nDeepMind,   \nLondon, UK ",
+        "bbox": [
+            183,
+            195,
+            681,
+            237
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            273,
+            544,
+            289
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The ability of algorithms to evolve or learn (compositional) communication protocols has traditionally been studied in the language evolution literature through the use of emergent communication tasks. Here we scale up this research by using contemporary deep learning methods and by training reinforcement-learning neural network agents on referential communication games. We extend previous work, in which agents were trained in symbolic environments, by developing agents which are able to learn from raw pixel data, a more challenging and realistic input representation. We find that the degree of structure found in the input data affects the nature of the emerged protocols, and thereby corroborate the hypothesis that structured compositional language is most likely to emerge when agents perceive the world as being structured. ",
+        "bbox": [
+            233,
+            304,
+            764,
+            457
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            482,
+            336,
+            498
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The study of emergent communication is important for two related problems in language development, both human and artificial: language evolution, the development of communication protocols from scratch (Nowak & Krakauer, 1999); and language acquisition, the ability of an embodied agent to learn an existing language. In this paper we focus on the problem of how environmental or pre-linguistic conditions affect the nature of the communication protocol that an agent learns. The increasing realism and complexity of environments being used for grounded language learning (Brockman et al., 2016; Hermann et al., 2017) present an opportunity to analyse these effects in detail. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            625
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In line with previous work on emergent communication, we are strongly motivated by the view that language derives meaning from its use (Wittgenstein, 1953; Wagner et al., 2003). This perspective especially motivates the study of language emergence in cases where co-operative agents try to achieve shared goals in game scenarios (Steels, 2003; Brighton & Kirby, 2006; Mordatch & Abbeel, 2017), and is related to the study of multi-agent and self-play methods that have found great success in other areas of machine learning (Bansal et al., 2017; Silver et al., 2017). Here we focus on simple referential games, in which one agent must communicate to another a target object in the agent’s environment. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One of the most important properties of natural language is compositionality. Smaller building blocks (e.g. words, morphemes) are used to generate unbounded numbers of more complex forms (e.g. sentences, multi-word expressions), with the meaning of the larger form being determined by the meanings of its parts and how they are put together (Frege, 1892). Compositionality is an advantage in any communication protocol as it allows in principle infinite expression through a finite dictionary and a finite set of combination rules. In emergent communication research, previous work has shown that agents can produce (somewhat) compositional protocols when engaging in language games (Steels, 2003). However, the computational agents were typically situated in artificial worlds containing just a handful of objects, represented as disentangled, structured, and sometimes even atomic symbols, e.g. attribute-based or one-hot vectors (Batali, 1998; Brighton, 2002; Franke, 2015; Andreas & Klein, 2017; Mordatch & Abbeel, 2017). However, humans receive raw sensorimotor rather than symbolic input, and little work to date has tested whether these findings carry over when agents are situated in less idealized worlds that bear more similarity to the kind of entangled and noisy environments to which humans are typically exposed.1 ",
+        "bbox": [
+            174,
+            750,
+            825,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/aea3a2fceb920cffdae0270c243ac52b72776e4d05ae8e6a4c4b0000f5f4d17a.jpg",
+        "image_caption": [
+            "Figure 1: High-level overview of the referential game. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            258,
+            98,
+            741,
+            297
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            358,
+            825,
+            400
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, in the context of referential communication games (see Figure 1), we contrast the results of two studies that lie at the extremes of how much structure is provided by the environment. The first study (Section 3) focuses on symbolic representations, where objects are represented as bags-of-attributes; this representation is inherently disentangled since dimensions encode individual properties. The second study (Section 4) considers raw perceptual input, hence data that more closely resembles what humans are exposed to. Clearly, the latter is a more challenging and realistic scenario as the computational agents are operating on entangled inputs with no pre-coded semantics. Crucially, both studies use the same referential game setup, the same learning procedure (policy learning methods) and the same neural network agent architectures. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            532
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We show that reinforcement learning agents can successfully communicate, not only when presented with symbolic and highly structured input data, but (and more importantly) even when presented with raw pixel input. This result opens up the possibility of more realistic simulations of language emergence. We successfully use the learning signal from the referential game to train agents end-to-end, including cases where the agents need to perform visual processing of images with a convolutional neural network. However, we find that the agents struggle to produce structured messages when presented with entangled input data (Bengio et al., 2013) due to the difficulty of uncovering the true factors of variation, corroborating the hypothesis of Smith et al. (2003) that structured (compositional) language is most likely to emerge when agents perceive the world as structured. ",
+        "bbox": [
+            174,
+            539,
+            825,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 REFERENTIAL GAMES AS MULTI-AGENT CO-OPERATIVEREINFORCEMENT LEARNING",
+        "text_level": 1,
+        "bbox": [
+            174,
+            699,
+            674,
+            732
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The referential game is implemented as an instance of multi-agent co-operative reinforcement learning, in which two agents take discrete actions in their environment in order to maximize a shared reward. ",
+        "bbox": [
+            174,
+            747,
+            823,
+            789
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 GAME AND TERMINOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            806,
+            403,
+            820
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The referential game is a variant of the Lewis signaling game (Lewis, 1969), which has been extensively used in linguistic and cognitive studies in the context of language evolution (e.g., Briscoe, 2002; Cangelosi & Parisi, 2002; Steels & Loetzsch, 2012; Spike et al., 2016; Lazaridou et al., 2017). ",
+        "bbox": [
+            174,
+            833,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 provides a schematic description of our setup. First, a speaker is presented with a target object (highlighted as CAR in the symbolic example on the left, and highlighted as the far right image in the pixel example on the right). Then, by making use of an alphabet consisting of primitive discrete symbols $( ^ { \\ast \\cdot } 2 2 ^ { \\cdot \\prime } , ^ { \\cdot \\cdot } 1 0 ^ { \\cdot \\prime } , ^ { \\cdot \\cdot } 0 ^ { \\cdot \\prime } , ^ { \\cdot \\cdot } 2 ^ { \\cdot \\prime } )$ , the speaker constructs a message describing that object (“22 $2 0 ^ { \\circ } )$ . We will refer to the set of all distinct messages generated by the speaker as their lexicon or protocol. Finally, the listener is presented with the target and a set of distractor objects, and—by making use of the speaker’s message—has to identify the target object from the set of candidate objects. Communicative success is defined as the correct identification of the target by the listening agent. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Formally, the attribute-based object vectors (disentangled) or the pixel-based images (entangled) are the set of pre-linguistic items $W = \\{ o _ { 1 } , \\ldots , o _ { N } \\}$ . From this set we draw a target $t \\in W$ and subsequently $K - 1$ distractors $D = \\{ d _ { 1 } , \\dots , d _ { K - 1 } \\} \\subset W$ s.t. ∀j $t \\neq d _ { j }$ . The speaker has only access to the target $t$ , while the listener receives candidate set $C = t \\cup D$ , not knowing which of the elements in $C$ is target $t$ . ",
+        "bbox": [
+            174,
+            236,
+            825,
+            306
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 AGENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            330,
+            272,
+            345
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The speaker encodes $t$ into a dense representation $u$ using an encoder $f ^ { S } ( t , \\theta _ { f } ^ { S } )$ . The function of this encoder depends on the type of pre-linguistic data used and is discussed separately for each study. Given an alphabet $A$ of discrete unit symbols (akin to words) and $u$ , the speaker next generates a discrete, variable-length, bounded message m by sampling symbols from a recurrent policy $\\pi ^ { S }$ defined by a decoder $\\check { g } ^ { S } ( u , \\theta _ { g } ^ { S } )$ . The sequence generation is terminated either by the production of a stop symbol or when the maximum length $L$ has been reached. We implement the decoder as a single-layer LSTM (Hochreiter $\\&$ Schmidhuber, 1997). Note that the symbols in the agents’ alphabet $A$ have no a priori meaning; rather, these symbols get grounded during the game. ",
+        "bbox": [
+            173,
+            359,
+            825,
+            474
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The listening agent uses a similar encoder to the speaker but has independent network weights $( \\theta _ { f } ^ { L } )$ . Applying this encoder to all candidate objects results in a set $U = \\{ f ^ { L } ( c , \\theta _ { f } ^ { L } ) \\mid c \\in C \\}$ . For encoding the message $\\mathbf { m }$ , we use a single-layer LSTM, denoted $h ^ { L }$ , which produces an encoding $z$ : $z = h ^ { L } ( \\mathbf { \\bar { m } } , \\theta _ { h } ^ { L } )$ . ",
+        "bbox": [
+            174,
+            479,
+            825,
+            544
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given encoded message $z$ and candidates $U$ , the listener predicts a target object $t ^ { \\prime } \\in C$ following a policy $\\pi ^ { L }$ implemented using a non-parametric pointing module; this module samples the predicted object from a Gibbs distribution computed via the dot product between vector $z$ and all encoded candidates $u \\in U$ . See Appendix B for information regarding the agents’ architecture. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            606
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "At inference time, we replace the stochastic sampling of the speaker’s message and the listener’s stochastic pointing module with deterministic processes. For the pointing module, the object with the highest probability is chosen. For the speaker’s message, this is generated in a greedy fashion by selecting the highest-probability symbol at each step. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            669
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            694,
+            290,
+            708
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "All weights of the speaker and listener agents, $\\theta = \\{ \\theta _ { f } ^ { S } , \\theta _ { g } ^ { S } , \\theta _ { f } ^ { L } , \\theta _ { h } ^ { L } \\}$ , are jointly optimized while playing the game. We emphasize that no weights are shared between the speaker and the listener, and the only supervision used is communicative success, i.e. whether the listener identified the correct target. The objective function that the two agents maximize for one training instance is: ",
+        "bbox": [
+            174,
+            723,
+            825,
+            781
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c34e2e7b58caa96bee6d7b21228b3df792fb3baa418ae30a187e41678a9fca7a.jpg",
+        "text": "$$\nR ( t ^ { \\prime } ) \\left( \\sum _ { l = 1 } ^ { L } \\log p ( m _ { t } ^ { l } | m _ { t } ^ { < l } , u ) + \\log p ( u _ { t ^ { \\prime } } | z , U ) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            796,
+            661,
+            839
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $R$ is the reward function returning 1 if $t = t ^ { \\prime }$ (if the listener pointed to the correct target) and 0 otherwise. To maintain exploration in the speaker’s policy $\\pi ^ { S }$ of generating a message, and the listener’s policy $\\pi ^ { L }$ of pointing to the target, we add to the loss an entropy regularization term (Mnih et al., 2016). The parameters are estimated using the REINFORCE update rule (Williams, 1992). See Appendix $\\mathbf { B }$ for more details regarding the learning. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/cfe7a03f798798062f8caf55337de20030b3afb133cfa3a577a1f4f6caf9f226.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>max length</td><td>alphabet size</td><td>lexicon size</td><td>training accuracy</td><td>topographic p</td></tr><tr><td>2</td><td>10</td><td>31</td><td>92.0%</td><td>0.13</td></tr><tr><td>5</td><td>17</td><td>293</td><td>98.2%</td><td>0.16</td></tr><tr><td>10</td><td>40</td><td>355</td><td>98.5%</td><td>0.26</td></tr></table>",
+        "bbox": [
+            225,
+            101,
+            772,
+            172
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Commumicative success (training accuracy in percentage) with varying maximum message length. alphabet size denotes the effective size of the symbol set used from a maximum of 100. lexicon size is the effective number of unique messages used. topographic $\\rho$ reports the structural similarity in terms of Spearman $\\rho$ correlation between the message and the object vector space. All Spearman $\\rho$ correlations throughout the paper are significant with $p < 0 . 0 1$ . ",
+        "bbox": [
+            173,
+            183,
+            825,
+            253
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 STUDY 1: REFERENTIAL GAME WITH SYMBOLIC DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            280,
+            656,
+            296
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We first present experiments where agents are learning to communicate when presented with structured and disentangled input. We use the Visual Attributes for Concepts Dataset (VisA) of Silberer et al. (2013), which contains human-generated per-concept attribute annotations for 500 concrete concepts (e.g., cat, sofa, car) spanning across different categories (e.g., mammals, furniture, vehicles), annotated with 636 general attributes (e.g., has tail, is black, has wheels). We disregarded homonym concepts (e.g., bat), thus reducing our working set of concepts to 463 and the number of attributes to 573 (after eliminating any attribute that did not occur with the working concepts). On average, each concept has 11 attributes. All pre-linguistic objects are represented in terms of binary vectors $o \\in \\{ 0 , 1 \\} ^ { 5 7 3 }$ . Note that these representations do carry some inherent structure; the dimensions in the object vectors are disentangled and so each object can be seen as a conjunction of properties. Speaker and listener convert the pre-linguistic representations to dense representations $u$ by using a single-layer MLP with a sigmoid activation function. ",
+        "bbox": [
+            174,
+            313,
+            825,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In all experiments, we set the number of candidate objects $K$ to five, meaning there were four wrong choices per correct one (resulting in a $2 0 \\%$ random baseline). Inspired by Kottur et al. (2017), who show that non-compositional language emerges in the case of overcomplete alphabets, we set the size of alphabet $A$ to 100 symbols, which is smaller than the size of the set of objects (463). ",
+        "bbox": [
+            176,
+            487,
+            825,
+            542
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 AGENT PERFORMANCE AND AMBIGUITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            563,
+            498,
+            577
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We first report model performance on the training data, comparing different settings for the maximal allowed message length (2, 5 or 10 symbols). Results are presented in Table 1 (ignore the last row topographic $\\rho$ which will be explained in later sections). ",
+        "bbox": [
+            178,
+            589,
+            823,
+            631
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the case of the shortest message settings (maximum length 2), our trained agents on average only develop a protocol of 31 unique messages used to describe 363 training concepts (leaving aside 100 for testing). This indicates high levels of ambiguity, with each message being used to denote 11 concepts on average. Interestingly, recent findings suggest that ambiguity is a design feature of language that prevents the inefficient use of redundant codes, since some of the message content can be extracted from context: “the most efficient communication system will not convey information already provided by the context” (Piantadosi et al., 2012). In our case, we do no explicitly encode any bias towards ambiguity. We hypothesize that ambiguity arises due to the difficult exploration problem that agents are faced with, in combination with the fact that ambiguous protocols present a good local optimum that is over-represented in the hypothesis search space. As a result, in the absence of environmental pressures (e.g., a high number of carefully constructed distractors) a suboptimal policy can still achieve a reasonably high accuracy $( 9 2 \\% )$ , making it even harder during training to escape from such a solution. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In classic signaling games, this polysemy phenomenon manifests itself as different states receiving the same signal and is termed partial pooling equilibrium (Skyrms, 2010). Perhaps rather counterintuitively, Skyrms (p.131) suggests that a way to obtain communication protocols that are robust to this type of local communication minima is to allow the invention of new signals, essentially increasing the search space of signals. Motivated by this suggestion, we play variants of the game in which we allow the agents to produce messages of greater maximum length (5 and 10), which leads to improved communicative success $9 8 . 2 \\%$ and $9 8 . 5 \\%$ respectively). We observe that the number of messages in the protocol increases from 31 to 293 and 355, respectively, reducing the average number of concepts a message can denote from 11 concepts to (approximately) 1 concept. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/f54b6c616adb9b6e25c20297338305d82c03c1c6cbacf39ded5809edadfd7eb1.jpg",
+        "image_caption": [
+            "Figure 2: Training curves of different experimental setups with uniform and context-dependent target selection. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            328,
+            99,
+            666,
+            284
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            359,
+            823,
+            388
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 REALISTIC CONTEXT DISTRIBUTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            410,
+            465,
+            424
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the real world, when speakers refer to cats, listeners would likely be in a situation where they had to discriminate a cat in the context of a couch or a dog, rather than in the context of a mirror or a cow.2 Simply put, objects in the world do not appear in random contexts, but rather there is regularity in the distribution of situational and visual co-occurrences. This property of the world is typically not captured in referential games studied in the language emergence literature, with distractors usually drawn from a uniform distribution. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            521
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We address this issue and design an additional experiment with distractors sampled from a targetspecific context distribution reflecting normalized object co-occurrence statistics. Co-occurrence data is extracted from the MSCOCO caption dataset (Lin et al., 2014). This leads to more plausible distractor sets with, for instance, the target goat more likely being mixed with sheep and cow as distractors rather than bike or eggplant. ",
+        "bbox": [
+            174,
+            529,
+            823,
+            598
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We find that the distractor selection process (uniform vs context-dependent) affects the language learning dynamics; see Figure 2 for training curves for different experimental configurations. While the non-uniform distractor sampling of the context-dependent setting can be exploited to learn a degenerate strategy —giving up to $40 \\%$ communicative success shortly after the start of training— subsequently learning under this scenario takes longer. This effect is likely a combination of the local minimum achieved by the degenerate strategy of picking a target at random from only the topically relevant set of distractors, which initially makes the problem easier; however, the fact that the co-occurrence statistics tend to align with the feature vectors, means that similar objects are more likely to appear as distractors and hence the overall game becomes more difficult. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            731
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now consider the question of how objects denoted by the same (ambiguous) message are related. When the context is drawn uniformly, object similarity is a predictor of object confusability, as similar objects tend to be mapped onto the same message (0.26 and 0.43 median pairwise cosine similarities of objects that received the same message as computed on the VisA space, for maximum message length 2 and 5, respectively). In the non-uniform case, we observe object confusability to be less influenced by object similarity (0.15 and 0.17 median pairwise cosine similarities of objects that received the same message, for maximum message length 2 and 5, respectively), but rather driven by the visual context co-occurrences. Simply put, in the non-uniform case confusability is less influenced by similarity since the agents must learn to distinguish between objects that naturally co-occur (e.g. sheep and goat). Thus, the choice of distractors, an experimental design decision that in existing language emergence literature has been neglected, has an effect on the organization (and potentially the naturalness) of the emerged language, for example as reflected in the semantics of ambiguous or homonym words in the language. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            890
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/b5d62f37e1521286a723390b44164c15effbb389a0bb345d2ce0bb07c67f4c45.jpg",
+        "table_caption": [
+            "Table 2: Communicative success (acc in percentage) of agents evaluated on training (first row) and novel (last three rows) data. lexicon size column reports the percentage of novel messages (i.e., messages that were not used during the training). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Data</td><td>length 2 lexicon size</td><td>acc.</td><td>length 5 lexicon size</td><td>acc.</td><td>length 10 lexicon size</td><td>acc.</td></tr><tr><td>training data</td><td>31</td><td>92.0</td><td>293</td><td>98.2</td><td>355</td><td>98.5</td></tr><tr><td>test data</td><td>1</td><td>74.2</td><td>70</td><td>76.8</td><td>98</td><td>81.6</td></tr><tr><td>unigram chimera</td><td>5</td><td>39.3</td><td>88</td><td>40.5</td><td>99</td><td>47.0</td></tr><tr><td>uniform chimera</td><td>3</td><td>31.2</td><td>87</td><td>32.2</td><td>100</td><td>42.6</td></tr></table>",
+        "bbox": [
+            222,
+            101,
+            776,
+            200
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            280,
+            823,
+            309
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 STRUCTURAL PROPERTIES OF EMERGED PROTOCOLS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            327,
+            578,
+            340
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Quantifying the degree of compositionality and structure found in the emerged language is a challenging task; to the best of our knowledge, there is no formal mathematical definition of compositionality that would allow for a definitive quantitative measure. Thus, research on this topic usually relies on defining necessary requirements that any language claiming to be compositional should adhere to, such as the ability to generalize to novel situations (Batali, 1998; Franke, 2015; Kottur et al., 2017). We adopt a similar strategy by measuring the extent to which an emerged language is able to generalize to novel objects (Section 3.3.1). Moreover, we also report quantitative results (Section 3.3.2) using a measure of message structure proposed in the language evolution literature (Brighton & Kirby, 2006; Carr et al., 2017). ",
+        "bbox": [
+            173,
+            353,
+            825,
+            478
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3.1 GENERALIZATION TO NOVEL OBJECTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            496,
+            493,
+            508
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We perform experiments where trained agents from Section 3.1 are exposed to different types of unseen objects, each of them differing to the degree to which the unseen objects resemble the objects found in the training data. In the test scenario, objects come from the same data distribution as the training data, but were not presented to the agents during training (e.g., a mouse); in the unigram chimeras scenario, the novel objects are constructed by sampling properties from a property-based distribution inferred from the training data, thus breaking any feature correlation (e.g., a mouselike animal with wheels); in the uniform chimeras scenario, the novel objects are constructed by uniformly sampling properties (e.g., a square red furry metallic object). ",
+        "bbox": [
+            174,
+            520,
+            825,
+            632
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2 reports the communicative success. While there is a drop in performance for unseen objects, agents are performing above random chance $( 2 0 \\% )$ . The emerged language is indeed able to generalize to unseen objects; however, the degree of generalization is a function of the similarity between the training and unseen objects, thus resulting in the uniform chimeras setting obtaining the lowest performance. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            708
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Moreover, we observe examples of productivity, a key feature of compositionality. At test time, speakers are able to concoct novel messages on-the-fly (i.e., messages that are not part of their lexicon induced during training) to describe unseen objects. See the last three rows of Table 2, and the lexicon size column, for the percentage of novel messages. Even though listeners were not trained to associate novel messages with novel objects, they are still able comprehend such messages and correctly identify the target object. In the test data and length 10 cases, novel messages account for almost all of the generated messages, but with performance at $8 1 . 6 \\%$ , providing evidence of the structure found in the messages. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            827
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3.2 TOPOGRAPHIC SIMILARITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            843,
+            416,
+            857
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Given a set of objects, their meanings and the associated signals, Brighton & Kirby (2006) define topographic similarity to be the correlation of the distances between all the possible pairs of meanings and the corresponding pairs of signals. Figure 3 shows mappings between states and signals for examples of holistic (b) and compositional (c,d) languages, with the topographic similarity of compositional languages being higher than that of holistic. The intuition behind this measure is that semantically similar objects should have similar messages. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/cd5d57f50366fee02fe1b3ce12b993334e48d59f130b088d0fbe530764268416.jpg",
+        "image_caption": [
+            "Figure 3: left: Three languages with different properties, taken from Brighton & Kirby (2006). The mapping between states and signals shown in (b) is random; there is no relationship between points in the meaning and signal space. In (c) and (d), similar meanings map to similar signals, i.e., there is a topographic relation between meanings and signals. right: Relation between objects’ cosine similarity and their message Levenshtein distance for trained and random agents. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            111,
+            764,
+            280
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            402,
+            823,
+            430
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To compute this measure, we first compute two lists of numbers: (i) the Levenshtein distances between all pairs of objects’ messages; and (ii) the cosine similarity between all pairs of objects’ VisA vectors. Given these two lists, the topographic similarity is defined as their negative Spearman $\\rho$ correlation (since we are correlating distances with similarities, negative values of correlation indicate topographic similarity of the two spaces). Intuitively, if similar objects share much of the message structure (e.g., common prefixes or suffixes), and dissimilar objects have little common structure in their respective messages, then the topographic similarity should be high, the highest possible value being 1. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            549
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results presented back in Table 1, in the topographic $\\rho$ column, show that topographic similarity is positive in all experimental setups, indicating that similar objects receive similar messages $( p < 0 . 0 1$ , permutation test). A qualitative analysis of the messages generated in the length 10 and training data cases showed that, for example, $32 \\%$ of the mammal objects had as a message prefix the bigram $9 5 \\# 1 0 ^ { \\star }$ ; $36 \\%$ of vehicle objects had $\\cdot 6 8 \\# 9 5 $ ; and $11 \\%$ of tool objects had ‘0#61’, suggesting that these prefix bigrams encode category-specific information. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            640
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Next, for each object pair, we calculate their Levenshtein message distance and respective cosine similarity, and plot in Figure 3 (right), for each distance, the average cosine similarities of the pairs with that distance (this is done for the length 10 and training data experiment). We observe that there is a clear relation between message similarity and meaning similarity (as measured by overlap in the VisA properties). In Figure 3, we also plot a similar correlation curve for an emerged language obtained by producing messages with randomly initialized and untrained speaker/listener architectures. This emerged language is at random in terms of communicative success; however, the generated messages do show signs of structure, since similar objects obtain somewhat similar messages. This seems to suggest that structured and disentangled pre-linguistic representations are, perhaps, a sufficient condition for the emergence of structured language, especially in neural network-based agents which, due to the nature of representation and information flow, favor similar inputs to trigger similar outputs. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            813
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 STUDY 2: REFERENTIAL GAME WITH RAW PIXEL DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            844,
+            660,
+            859
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present experiments in which agents receive as input entangled data in the form of raw pixel input, and have to learn to perform visual conceptual processing guided by the communication-based reward. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use a synthetic dataset of scenes consisting of geometric objects generated using the MuJoCo physics engine (Todorov et al., 2012). We generate RGB images of resolution $1 2 4 \\times 1 2 4$ depicting single object scenes. For each object, we pick one of eight colors (blue, red, white, black, yellow, green, cyan, magenta) and five shapes (box, sphere, cylinder, capsule, ellipsoid) resulting in 40 combinations, for each of which we generate 100 variations, varying the floor color and the object location in the image. Moreover, we introduce different variants of the game: game A with 19 distractors; game B with 1 distractor; game C with 1 distractor, and with speaker and listener having different viewpoints of the target object (the target object on the listener’s side is in a different location); game D with 1 distractor, with speaker and listener having different viewpoints, and with balanced numbers of shapes and color (obtained by downsampling from 8 colors to 5 and removing any image containing objects of the 3 disregarded objects). For each game, we create train and test splits with proportions 75/25 (i.e., 3000/1000 for games A and B, and 1850/650 for games C and D). ",
+        "bbox": [
+            174,
+            104,
+            825,
+            284
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Pre-linguistic objects are presented in the form of pixel input, $o \\in [ 0 , 2 5 5 ] ^ { 3 \\times 1 2 4 \\times 1 2 4 }$ . Speaker and listener convert the images $o$ to dense representations $u$ , each of them using an 8-layer convolutional neural network (ConvNet). Crucially, we do not pre-train the ConvNets on an object classification task; the only learning signal is the communication-based reward. Despite this fact, we observe that the lower layers of the ConvNets are encoding similar information to a ConvNet pre-trained on ImageNet (Deng et al., 2009).3 Conceptually, we can think of the whole speaker/listener architecture as an encoder-decoder with a discrete bottleneck (the message). Given our initial positive findings, this reward-based learning signal induced from the communication game setup could be used for classagnostic large-scale ConvNet training. Moreover, we find that, even though no weights were shared, the agents’ conceptual spaces get aligned at different levels, reminiscent of theories of interactive conceptual alignment during dialogue (Garrod & Pickering, 2004) (see Appendix A for the related experiment). ",
+        "bbox": [
+            174,
+            290,
+            825,
+            457
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1 COMMUNICATIVE SUCCESS AND EMERGENT PROTOCOLS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            483,
+            606,
+            494
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Unlike the experiments of Section 3, where agents start from disentangled representations, starting from raw perceptual input presents a greater challenge: the agents have to establish naming conventions about scenes, while at the same time learning to process the input with their own visual conceptual system. Since we do not pre-train their ConvNets on an object recognition task, the dense representations $u$ used to derive the message contain no bias towards any image- or scene-specific information (e.g, object color, shape or location). The extraction of visual properties is thus driven entirely by the communication game. This contrasts with the cases of Havrylov & Titov (2017) and Lazaridou et al. (2017) who use pre-trained visual vectors, and qualitatively observe that the induced communication protocols encode information about objects. Table 3 presents the results in terms of communicative train and test success (see Appendix C for additional experiments when having access to gold object attribute classifiers). Moreover, we also report the topographic similarity (column topographic $\\rho \\mathrm { \\Sigma }$ ) between the symbolic attribute-based representations of scenes (floor color, object color, shape and location) and the generated messages. ",
+        "bbox": [
+            174,
+            510,
+            825,
+            690
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Overall, despite the challenges posed in this setup due to the raw nature of the data, performance across all games is well above chance, indicating that reinforcement learning agents trained end-toend are able to establish a communication protocol in this grounded environment. In game A, the agents reach $9 3 . 7 \\%$ accuracy, with their lexicon consisting of 1068 messages, describing 3000 training objects. Most importantly, as captured by the positive topographic similarity, agents produce messages that respect (even to a limited degree) the compositional nature of scenes (i.e., objects as bags-of-attributes), indicating that similar scenes receive similar messages. Indeed, by examining their protocol (see Table 4), we find that messages encode in a structurally consistent way information about absolute location of objects, with the message prefix and suffix denoting the horizontal and vertical co-ordinate, respectively. Interestingly, this communication strategy is also typically followed by human players of referential games (Kazemzadeh et al., 2014). ",
+        "bbox": [
+            174,
+            696,
+            825,
+            849
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/1a48df6cd3a8b1c8b52b9ee8420e381abf4d505b03645f3a5586570289a52a63.jpg",
+        "image_caption": [
+            "Figure 4: Target images and their associated messages from game A and game B. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            98,
+            751,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/1c33ae529b690363a8814473c5a0fd58333daa521703fa23bcc5b642ee753936.jpg",
+        "table_caption": [
+            "Table 3: Communicative success of agents playing different games. Columns random, train and test report percentage accuracies. Column topographic $\\rho$ reports the topographic similarity between the symbolic representation of scenes and the generated messages $( p < 0 . 0 1$ , permutation test). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>game</td><td>distractors</td><td>balanced</td><td>viewpoints</td><td>lexicon size</td><td>random</td><td>train</td><td>test</td><td>topographic p</td></tr><tr><td>A</td><td>20</td><td>No</td><td>No</td><td>1068</td><td>5.0</td><td>93.7</td><td>93.6</td><td>0.13</td></tr><tr><td>B</td><td>2</td><td>No</td><td>No</td><td>13</td><td>50.0</td><td>93.2</td><td>93.4</td><td>0.006</td></tr><tr><td>C</td><td>2</td><td>No</td><td>Yes</td><td>8</td><td>50.0</td><td>86.0</td><td>85.7</td><td>0.07</td></tr><tr><td>D</td><td>2</td><td>Yes</td><td>Yes</td><td>5</td><td>50.0</td><td>90.4</td><td>89.9</td><td>0.06</td></tr></table>",
+        "bbox": [
+            173,
+            297,
+            839,
+            377
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "However, we find the emerged protocols to be very unstable and too grounded in the specific game situation. Small modifications of the game setup, while having close to no negative impact on the communicative performance, can radically alter the form, semantics and interpretability of the communication protocol. In game B, performance remains at the same level $( 9 3 . 2 \\% )$ as game A. However, we observe that the protocol consists of 13 unique messages which do not reflect the objects’ attributes (as indicated by the close to zero topographic similarity), thus making the messages harder to interpret (see Figure 4 for randomly sampled examples). When we change the viewpoint of the agents in game C, biasing them against communicating about absolute object location, the players derive a compact communication protocol consisting of 8 unique messages that describe primarily color. Finally, when color and shape are balanced, as in game $\\mathbf { D }$ , we still observe a bias towards describing the color of objects, with the five induced messages providing a perfect clustering of the objects according to their colors.4 ",
+        "bbox": [
+            174,
+            462,
+            825,
+            628
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In an entangled world, agents do not possess a priori visual biases and knowledge of concepts. Since objects can be conceptualized in indefinitely many ways, the type of information encoded in the messages is tied to the environmental pressures; communication behaviour is a function of the environment, which also dictates what data structures can emerge. The implication of this observation is that protocols essentially overfit to the particular game situation, to the degree that they become specialized ad-hoc naming conventions. ",
+        "bbox": [
+            174,
+            636,
+            823,
+            719
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, the emergence of ad-hoc naming conventions has also been observed during humanhuman interaction: when participants engage in some specific game situation (e.g., communicating about abstract tangram shapes), they tend to form highly specialized naming conceptions (conceptual pacts) that allow them to communicate with maximum efficiency (Brennan & Clark, 1996). While in this study we do not address the issue of how a stable and general language could emerge in entangled worlds, we believe that to alleviate the formation of such ad-hoc communication protocols, it is essential to increase the complexity of the games as well as requiring transfer across a variety of games. ",
+        "bbox": [
+            174,
+            726,
+            825,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/4008750bcb61befc4a824c46e6a1c278195b2e16c83358d4b9cad74b5cc97c8a.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 4: Accuracy of probe linear classifiers of speaker’s induced visual representations (all accuracies are in percentage format). "
+        ],
+        "table_body": "<table><tr><td>game (random baseline)</td><td>object position (20.0)</td><td>object shape (20.0)</td><td>object color (12.0)</td><td>floor color (33.0)</td></tr><tr><td>A</td><td>95.3</td><td>90.2</td><td>24.7</td><td>36.4</td></tr><tr><td>B</td><td>88.6</td><td>41.2</td><td>63.8</td><td>45.4</td></tr><tr><td>C</td><td>85.9</td><td>43.5</td><td>65.8</td><td>43.8</td></tr><tr><td>D</td><td>89.4</td><td>47.1</td><td>82.0</td><td>42.3</td></tr></table>",
+        "bbox": [
+            250,
+            101,
+            748,
+            193
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.2 PROBE MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            257,
+            325,
+            271
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In order to investigate what information gets captured by the speaker’s ConvNet, we probe the inferred visual representations $u$ used to derive the message. Specifically, we design 4 probe classifiers for the color and shape of the object; object position which is derived by discretizing each co-ordinate into 3 bins; and floor color which is obtained by clustering the RGB color representation of the floor. For each probe, we performed 5-fold cross validation with a linear classifier, and report accuracy results in Table 4. Overall, different games result in visual representations with different predictive power; object position is almost always encoded in the speaker’s visual representation, even in situations where location of the object is not a good strategy for communication. On the other hand, object shape seems to provide less salient information, despite the fact that it is relevant for communication, at least in the C&D games. ",
+        "bbox": [
+            174,
+            284,
+            825,
+            422
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As expected, the structure and semantics of the emergent protocols are a function of the information captured in the visual representations. The degree to which the agents are able to pull apart the objects’ factors of variation impacts their ability to communicate about those factors, with the most extreme case being game D, where the message ignores the shape entirely. Thus, disentanglement seems to be a necessary condition for communication, at least in the case of pixel input. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            498
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            518,
+            318,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We presented a series of studies investigating the properties of protocols emerging when reinforcement learning agents are trained end-to-end on referential communication games. We found that when agents are presented with disentangled input data in the form of attribute vectors, this inherent compositional structure is successfully retained in the output. Moreover, we showed that communication can also be achieved in cases where agents are presented with raw pixel data, a type of input that aligns better with the raw sensorimotor data that humans are exposed to. At the same time, we found that their ability to form compositional protocols in these cases is hampered by their ability to pull apart the objects’ factors of variations. Altogether, we were able to successfully scale up traditional research from the language evolution literature on emergent communication tasks to the contemporary deep learning framework, thus opening avenues to more realistic, and large scale, computational simulations of language emergence with complex image stimuli. ",
+        "bbox": [
+            174,
+            551,
+            825,
+            704
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            726,
+            367,
+            741
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Murray Shanahan, Laura Rimell and Gabor Melis for their very helpful feedback on this paper, as well as the rest of the DeepMind language team for many discussions. AL would also like to thank Marco Baroni and Alex Peysakhovich for the email correspondence and discussions from a year ago, which provided inspiration for some of the experiments on this paper. ",
+        "bbox": [
+            176,
+            757,
+            825,
+            813
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            834,
+            285,
+            849
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jacob Andreas and Dan Klein. Analogs of linguistic structure in deep representations. arXiv preprint arXiv:1707.08139, 2017. ",
+        "bbox": [
+            173,
+            857,
+            823,
+            885
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Trapit Bansal, Jakub Pachocki, Szymon Sidor, Ilya Sutskever, and Igor Mordatch. Emergent complexity via multi-agent competition. arXiv preprint arXiv:1710.03748, 2017. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John Batali. Computational simulations of the emergence of grammar. pp. 405–426, 1998. ",
+        "bbox": [
+            168,
+            103,
+            767,
+            119
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. IEEE transactions on pattern analysis and machine intelligence, 35(8):1798–1828, 2013. ",
+        "bbox": [
+            176,
+            127,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Susan E Brennan and Herbert H Clark. Conceptual pacts and lexical choice in conversation. Journal of Experimental Psychology: Learning, Memory, and Cognition, 22(6):1482, 1996. ",
+        "bbox": [
+            169,
+            179,
+            825,
+            209
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Henry Brighton. Compositional syntax from cultural transmission. Artificial life, 8(1):25–54, 2002. ",
+        "bbox": [
+            171,
+            218,
+            823,
+            233
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Henry Brighton and Simon Kirby. Understanding linguistic evolution by visualizing the emergence of topographic mappings. Artificial life, 12(2):229–242, 2006. ",
+        "bbox": [
+            171,
+            242,
+            825,
+            272
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ted Briscoe (ed.). Linguistic evolution through language acquisition. Cambridge University Press, Cambridge, UK, 2002. ",
+        "bbox": [
+            173,
+            280,
+            825,
+            309
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016. ",
+        "bbox": [
+            173,
+            318,
+            823,
+            348
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Angelo Cangelosi and Domenico Parisi (eds.). Simulating the evolution of language. Springer, New York, 2002. ",
+        "bbox": [
+            173,
+            356,
+            821,
+            386
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jon W Carr, Kenny Smith, Hannah Cornish, and Simon Kirby. The cultural evolution of structured languages in an open-ended, continuous world. Cognitive science, 41(4):892–923, 2017. ",
+        "bbox": [
+            171,
+            395,
+            821,
+            424
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. IEEE, 2009. ",
+        "bbox": [
+            173,
+            433,
+            825,
+            477
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Katrina Evtimova, Andrew Drozdov, Douwe Kiela, and Kyunghyun Cho. Emergent language in a multi-modal, multi-step referential game. arXiv preprint arXiv:1705.10369, 2017. ",
+        "bbox": [
+            173,
+            484,
+            823,
+            515
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Franke. The evolution of compositionality in signaling games. Journal of Logic, Language and Information, pp. 1–23, 2015. ",
+        "bbox": [
+            173,
+            523,
+            823,
+            553
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gottlob Frege. Uber Sinn und Bedeutung. ¨ Zeitschrift fur Philosophie und philosophische Kritik ¨ , 100:25–50, 1892. ",
+        "bbox": [
+            173,
+            561,
+            823,
+            590
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Simon Garrod and Martin J Pickering. Why is conversation so easy? Trends in cognitive sciences, 8(1):8–11, 2004. ",
+        "bbox": [
+            173,
+            599,
+            823,
+            628
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Serhii Havrylov and Ivan Titov. Emergence of language with multi-agent games: Learning to communicate with sequences of symbols. arXiv preprint arXiv:1705.11192, 2017. ",
+        "bbox": [
+            173,
+            637,
+            823,
+            667
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            176,
+            676,
+            820,
+            719
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karl Moritz Hermann, Felix Hill, Simon Green, Fumin Wang, Ryan Faulkner, Hubert Soyer, David Szepesvari, Wojtek Czarnecki, Max Jaderberg, Denis Teplyashin, et al. Grounded language learning in a simulated 3d world. arXiv preprint arXiv:1706.06551, 2017. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            772
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            171,
+            780,
+            823,
+            809
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sahar Kazemzadeh, Vicente Ordonez, Mark Matten, and Tamara L Berg. Referitgame: Referring to objects in photographs of natural scenes. In EMNLP, pp. 787–798, 2014. ",
+        "bbox": [
+            173,
+            818,
+            825,
+            848
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Satwik Kottur, Jose MF Moura, Stefan Lee, and Dhruv Batra. Natural language does not ´ emerge’naturally’in multi-agent dialog. arXiv preprint arXiv:1706.08502, 2017. ",
+        "bbox": [
+            173,
+            857,
+            820,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Angeliki Lazaridou, Alexander Peysakhovich, and Marco Baroni. Multi-agent cooperation and the emergence of (natural) language. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Lewis. Convention. Harvard University Press, Cambridge, MA, 1969. ",
+        "bbox": [
+            173,
+            103,
+            676,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ European conference on computer vision, pp. 740–755. Springer, 2014. ",
+        "bbox": [
+            176,
+            127,
+            823,
+            171
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning, pp. 1928–1937, 2016. ",
+        "bbox": [
+            178,
+            178,
+            825,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Igor Mordatch and Pieter Abbeel. Emergence of grounded compositional language in multi-agent populations. arXiv preprint arXiv:1703.04908, 2017. ",
+        "bbox": [
+            171,
+            231,
+            823,
+            260
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Martin A Nowak and David C Krakauer. The evolution of language. Proceedings of the National Academy of Sciences, 96(14):8028–8033, 1999. ",
+        "bbox": [
+            169,
+            268,
+            825,
+            296
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Steven T Piantadosi, Harry Tily, and Edward Gibson. The communicative function of ambiguity in language. Cognition, 122(3):280–291, 2012. ",
+        "bbox": [
+            171,
+            306,
+            823,
+            335
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Carina Silberer, Vittorio Ferrari, and Mirella Lapata. Models of semantic representation with visual attributes. In Proceedings of the 51st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 572–582, Sofia, Bulgaria, August 2013. Association for Computational Linguistics. URL http://www.aclweb.org/anthology/P13-1056. ",
+        "bbox": [
+            173,
+            343,
+            825,
+            400
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, Yutian Chen, Timothy Lillicrap, Fan Hui, Laurent Sifre, George van den Driessche, Thore Graepel, and Demis Hassabis. Mastering the game of go without human knowledge. Nature, 550:354–359, 2017. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            465
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Brian Skyrms. Signals: Evolution, learning, and information. Oxford University Press, 2010. ",
+        "bbox": [
+            171,
+            474,
+            787,
+            489
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kenny Smith, Simon Kirby, and Henry Brighton. Iterated learning: A framework for the emergence of language. Artificial life, 9(4):371–386, 2003. ",
+        "bbox": [
+            174,
+            498,
+            823,
+            527
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthew Spike, Kevin Stadler, Simon Kirby, and Kenny Smith. Minimal requirements for the emergence of learned signaling. Cognitive Science, 2016. In press. ",
+        "bbox": [
+            173,
+            536,
+            823,
+            565
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Luc Steels. Social language learning. In Mario Tokoro and Luc Steels (eds.), The Future of Learning, pp. 133–162. IOS, Amsterdam, 2003. ",
+        "bbox": [
+            174,
+            574,
+            823,
+            603
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Luc Steels and Martin Loetzsch. The grounded naming game. In Luc Steels (ed.), Experiments in Cultural Language Evolution, pp. 41–59. John Benjamins, Amsterdam, 2012. ",
+        "bbox": [
+            173,
+            611,
+            823,
+            641
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012. ",
+        "bbox": [
+            173,
+            648,
+            826,
+            691
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kyle Wagner, James A Reggia, Juan Uriagereka, and Gerald S Wilkinson. Progress in the simulation of emergent communication and language. Adaptive Behavior, 11(1):37–69, 2003. ",
+        "bbox": [
+            173,
+            700,
+            823,
+            731
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Mach. Learn., 8(3-4):229–256, May 1992. ISSN 0885-6125. doi: 10.1007/ BF00992696. URL https://doi.org/10.1007/BF00992696. ",
+        "bbox": [
+            174,
+            738,
+            823,
+            781
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ludwig Wittgenstein. Philosophical Investigations. Blackwell, Oxford, UK, 1953. Translated by G.E.M. Anscombe. ",
+        "bbox": [
+            169,
+            790,
+            823,
+            819
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A CONCEPTUAL ALIGNMENT OF SPEAKER AND LISTENER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            666,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "During conversation, communication allows interlocutors to achieve interactive conceptual alignment (Garrod & Pickering, 2004). We are able to communicate because we have established a common ground and our representations at different levels become aligned (e.g., participants mutually understand that “he” in the conversation refers to Bob). We investigated whether the agents’ conceptual systems achieve a similar structural alignment. We measure the alignment in terms of Spearman $\\rho$ correlation of the intra-agent pairwise object cosine similarities as calculated via representing objects as activations from ConvNet layers. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            231
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, we observe a gradual increase in the structural similarity as we represent the objects with layer activations closer to the pixel space. Conceptual spaces are more aligned the closer they are to the raw pixel input $\\mathrm { ~ \\ ' ~ } \\rho = 0 . 9 7 \\mathrm { - } 0 . 9 1$ , depending on the game) and become more dissimilar as the representations become more abstract. We can draw the analogy to language processing, as first ConvNet layers perform some low-level processing analogous to phoneme recognition or word segmentation (and are thus more objective) while higher layers perform more abstract processing, vaguely analogous to semantics and pragmatics (thus, represent more subjective knowledge). In cases of successful communication, speakers’ and listeners’ conceptual spaces closer to the communication point are structurally very similar $\\prime \\rho = 0 . 8 5 – 0 . 6 2$ , depending on the game), however this similarity drops dramatically in cases of failure of communication $\\mathit { \\Pi } _ { \\rho } = 0 . 1 5 $ ). ",
+        "bbox": [
+            174,
+            238,
+            825,
+            377
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B HYPERPARAMETER DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            397,
+            444,
+            414
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "All LSTM hidden states of the “speaking” and “listening” module as well and the “seeing” prelinguistic feed-forward encoders (see Section 3), have dimension 50. The “seeing” pre-linguistic ConvNet encoders (see Section 4) has 8 layers, 32 filters with the kernel size 3 for every layer and with strides $[ 2 , 1 , 1 , 2 , 1 , 2 , 1 , 2 ]$ for each layer. We use ReLU as activation function as well as batch normalization for every layer. ",
+        "bbox": [
+            174,
+            428,
+            823,
+            500
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For learning, we used the Rmsprop optimizer, with learning rate 0.0001. We use a separate value of entropy regularization for each policy. For $\\pi ^ { S }$ we use 0.01 and for $\\pi ^ { L }$ we use 0.001. We use a mini-batch of 32. ",
+        "bbox": [
+            176,
+            506,
+            823,
+            546
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C COMMUNICATIVE SUCCESS USING GOLD ATTRIBUTE CLASSIFIERS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            569,
+            754,
+            583
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We assume a model which has access to perfect attribute classifiers for color, shape and object position, for the latter using a classifier operating on the discretized annotations we obtained in Section 4.2 after quantazing the real-valued object location. For computing the performance of this model using gold attribute classifiers, we first remove from the distractors any candidate not matching the target’s attributes and them pick at random. We repeat this experiment for single attribute classifiers and their pairwise combinations. Table 5 reports the communicative success results obtained empirically by averaging across 1000 simulations, alongside the training and test accuracies of the trained agents of Section 4.1 for comparison. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            710
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/4818f702a613ac7e52f8690ab546facbc7e7d7d02b696c76a5dc6baf197721bc.jpg",
+        "table_caption": [
+            "Table 5: Communicative success of trained models from Section 4.1 (train and test) as well as models with access to gold classifiers. All accuracies are in percentage format. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td> game</td><td>train</td><td>test</td><td>color</td><td>shape</td><td>position</td><td>color &amp; shape</td><td> position &amp; shape</td><td>position &amp; color</td></tr><tr><td>A</td><td>93.7</td><td>93.6</td><td>37.2</td><td>24.8</td><td>69.3</td><td>80.4</td><td>92.1</td><td>95.6</td></tr><tr><td>B</td><td>93.2</td><td>93.4</td><td>93.2</td><td>90.1</td><td>97.2</td><td>98.8</td><td>99.3</td><td>99.4</td></tr><tr><td>C</td><td>86.0</td><td>85.7</td><td>93.2</td><td>90.1</td><td>-</td><td>98.8</td><td>1</td><td>1</td></tr><tr><td>D</td><td>90.4</td><td>89.9</td><td>89.6</td><td>89.2</td><td>1</td><td>98.5</td><td>1</td><td>1</td></tr></table>",
+        "bbox": [
+            174,
+            803,
+            854,
+            882
+        ],
+        "page_idx": 12
+    }
+]

parse/train/S1gd7nCcF7/S1gd7nCcF7.md

@@ -0,0 +1,229 @@
+# SELF-SUPERVISED GENERALISATION WITH META AUXILIARY LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Auxiliary learning has been shown to improve the generalisation performance of a principal task. But typically, this requires manually-defined auxiliary tasks based on domain knowledge. In this paper, we consider that it may be possible to automatically learn these auxiliary tasks to best suit the principal task, towards optimum auxiliary tasks without any human knowledge. We propose a novel method, Meta Auxiliary Learning (MAXL), which we design for the task of image classification, where the auxiliary task is hierarchical sub-class image classification. The role of the meta learner is to determine sub-class target labels to train a multi-task evaluator, such that these labels improve the generalisation performance on the principal task. Experiments on three different CIFAR datasets show that MAXL outperforms baseline auxiliary learning methods, and is competitive even with a method which uses human-defined sub-class hierarchies. MAXL is self-supervised and general, and therefore offers a promising new direction towards automated generalisation.
+
+# 1 INTRODUCTION
+
+Auxiliary learning is a method to improve the generalisation of a task. It works by training on additional auxiliary tasks simultaneously with the principal task. Extra data may be available for those auxiliary tasks, but not the principal task. If the auxiliary tasks and the principal task share some common reasoning, then the prediction model is encouraged to learn additional relevant features which otherwise would not be learned from single-task learning. The broader support of these features then assists with generalisation of the principal task.
+
+We now rethink this generalisation by considering that not all auxiliary tasks are created equal. In supervised auxiliary learning (Liebel & Korner, 2018; Toshniwal et al., 2017), auxiliary tasks can be ¨ carefully chosen to complement the principal task, but at the expense of a dependency on labelled data. Unsupervised auxiliary learning (Flynn et al., 2016; Zhou et al., 2017; Zhang et al., 2018; Jaderberg et al., 2017) alleviates this, but at the expense of a limited set of auxiliary tasks which may not be well aligned with the principal task. By combining the merits of both supervised and unsupervised auxiliary learning, the ideal auxiliary learning framework is one with the flexibility to automatically determine the optimum auxiliary tasks, but without the requirement of any manuallylabelled data.
+
+In this paper, we propose to achieve such a framework with a simple and general meta-learning algorithm which we call Meta AuXiliary Learning (MAXL). Given a principal task, the goal of MAXL is to discover the auxiliary tasks which, when trained alongside the principal task, give the greatest generalisation performance of the principal task on a meta dataset. In our work, we focus on the problem of image classification, where an auxiliary task is required to assign a sub-class label to an image. As such, data is classified both at a coarse level as the principal task, and at a fine level as the auxiliary task. The meta learner’s role is then to determine the target labels for this sub-class labelling, in such a way that the learned features induced by learning these additional, more complex auxiliary tasks generate the best generalisation performance for the principal task.
+
+As well as our method being able to automatically learn the optimum auxiliary tasks, we achieve this in an unsupervised manner, giving potential to scale well beyond any datasets without manuallylabelled auxiliary tasks, such as a class hierarchy as in our experiments. And even when such a hierarchy is available, in our experiments we show that MAXL is at least as competitive despite this hierarchy being learned in an unsupervised manner. In our experiments, we define the auxiliary tasks as sub-class labelling with MAXL learning to generate target sub-class labels, but MAXL is general and in future work this could be relaxed to actually learn the auxiliary tasks themselves. The ability to learn these tasks in a purely unsupervised and scalable manner opens up an exciting new way of thinking about how we can achieve generalisation in an automated manner.
+
+![](images/9be7e47f76a69d61e122286e9e1ded5295110c346ed9a4f5ad2eac73b4c4eaa3.jpg)  
+Figure 1: Illustration of our proposed MAXL framework. The Multi-task evaluator takes an input image and is trained to predict both the principal class (e.g. Dog), and the auxiliary class (e.g. Border Collie). The principal class has a ground-truth label, but the label for the auxiliary class is determined by the meta generator. The meta generator is trained by outputting auxiliary class labels which, when used to train the multi-task evaluator, improve its prediction performance on the principal task.
+
+# 2 RELATED WORK
+
+This work brings ideas together from a number of related areas of machine learning.
+
+Multi-task & Transfer Learning The aim of multi-task learning (MTL) is to achieve shared representations by simultaneously training a set of related learning tasks. In this case, the learned knowledge used to share across domains is encoded into the feature representations, to improve performance of each individual task, since knowledge distilled from related tasks are interdependent. The success of deep neural networks has led to some recent methods advancing the multi-task architecture design, such as applying a linear combination of task-specific features (Misra et al., 2016; Doersch & Zisserman, 2017; Kokkinos, 2017). Liu et al. (2018) applied soft-attention modules as feature selectors, allowing learning of both task-shared and task-specific features in a selfsupervised, end-to-end manner. Transfer learning is another common approach to improve generalisation, by incorporating knowledge learned from one or more related domains. Pre-training a model with a large-scale dataset such as ImageNet (Deng et al., 2009) has become standard practise in many vision-based applications. The transferability of different convolutional layers in CNNs has also been investigated in Yosinski et al. (2014).
+
+Auxiliary Learning Whilst in multi-task learning the goal is high test accuracy across all tasks, auxiliary learning differs in that high test accuracy is only required for a single principal task, and the role of the auxiliary tasks is to assist in generalisation of this principal task. Toshniwal et al. (2017) applied auxiliary supervision with phoneme recognition at intermediate low-level representations of deep networks to improve the performance of conversational speech recognition. Liebel & Korner ¨ (2018) chose auxiliary tasks which can be obtained with low effort, such as global descriptions of a scene, to boost the performance for single scene depth estimation and semantic segmentation. By carefully choosing a pair of learning tasks, we may also perform auxiliary learning without ground truth labels, in an unsupervised manner. Jaderberg et al. (2017) introduced a method for improving the learning agents in Atari games, by building unsupervised auxiliary tasks to predict the onset of immediate rewards from a short historical context. Flynn et al. (2016); Zhou et al. (2017) proposed image synthesis networks to perform unsupervised monocular depth estimation by predicting the relative pose of multiple cameras. Different from these works which require prior knowledge to manually define suitable auxiliary tasks, our proposed method requires no additional task knowledge, since our meta learner generates useful auxiliary knowledge in a purely unsupervised fashion. The most similar work to ours is Zhang et al. (2018), in which meta learning was used in auxiliary data selection. However, this still requires manually-labelled data from which these selections are made, whilst our method is able to generate auxiliary data from scratch.
+
+Meta Learning Meta learning (or learning to learn) aims to design a higher-level learning system which itself is trained using the experiences of a lower-level learning system, in an attempt to improve this lower-level system. Early works in meta learning explored automatically learning update rules for neural models (Bengio et al., 1990; 1992; Schmidhuber, 1992). Recent approaches have focused on learning optimisers for deep networks based on LSTMs (Ravi & Larochelle, 2016) or synthetic gradients (Andrychowicz et al., 2016; Jaderberg et al., 2016). Meta learning has also been studied for finding optimal hyper-parameters (Li et al., 2017) and a good initialisation for few-shot learning (Finn et al., 2017). (Santoro et al., 2016) also investigated few shot learning via an external memory module. Vinyals et al. (2016); Snell et al. (2017) realised few shot learning in the instance space via a differentiable nearest-neighbour approach. Our method also performs in the instance space, but induces auxiliary knowledge as an implicit regularisation to improve generalisation of the principal task.
+
+# 3 META AUXILIARY LEARNING
+
+In this section, we introduce our method for automatically generating optimum auxiliary tasks, which we call Meta AuXiliary Learning (MAXL).
+
+# 3.1 PROBLEM SETUP
+
+The goal of meta auxiliary learning is to train a meta generator that can generate higher complexity auxiliary tasks, to improve performance of the principal task. To accomplish this, we use two networks: a multi-task evaluator which trains on the principal and auxiliary tasks, and evaluates the performance of the auxiliary tasks on a meta set, and a meta generator which generates these auxiliary tasks. For simplicity, we consider image classification tasks in this section, where the auxiliary task is sub-class labelling, and the meta generator determines target sub-class labels, but the approach can be considered general for any type of task.
+
+We denote the multi-task evaluator as a function $f _ { \theta _ { 1 } } ( x )$ that takes an input $x$ with network parameters $\theta _ { 1 }$ , and the meta generator as a function $g _ { \theta _ { 2 } } ( x )$ that takes the same input $x$ with network parameters $\theta _ { 2 }$ . For a dataset with input $x$ and ground-truth label $y$ for the principal task, we split into three subsets: training $( x _ { \mathrm { t r a i n } } , y _ { \mathrm { t r a i n } } )$ , meta-training $( x _ { \mathrm { m e t a } } , y _ { \mathrm { m e t a } } )$ , and test $( x _ { \mathrm { t e s t } } , y _ { \mathrm { t e s t } } )$ . Training data is used for updating $\theta _ { 1 }$ , meta-training data is used for updating the $\theta _ { 2 }$ , and test data is used for overall evaluation.
+
+In the multi-task evaluator, we apply a hard parameter sharing approach (Ruder, 2017) in which we predict the principal and auxiliary tasks using the shared set of features $\theta _ { 1 }$ in the multi-task network. At the end of the last feature layer $f _ { \theta _ { 1 } } ( x )$ , we then apply further task-specific layers to output the corresponding prediction for each task. We denote the predicted principal labels by $f _ { \theta _ { 1 } } ^ { \mathrm { p r i } } ( x )$ and predicted auxiliary labels by $f _ { \theta _ { 1 } } ^ { \mathrm { a u x } } ( x )$ .
+
+In the meta generator, we pre-define a hierarchical structure $\psi$ which determines the number of subclasses for each class in the principal task. At the end of the last feature layer $g _ { \theta _ { 2 } } ( x )$ , this hierarchy, together with the ground-truth label $y$ for the principal task, are used to generate the target auxiliary labels, denoted by $g _ { \theta _ { 2 } } ^ { \mathrm { g e n } } ( x , y , \psi )$ . We allow for soft assignment labelling rather than enforcing onehot encoding, which enables greater flexibility to learn optimum auxiliary tasks. The meta generator uses a masked SoftMax to ensure that each output node represents a sub-class label for only one class in the principal task, as described further in Section 3.3. The visualisation of the our proposed MAXL approach is shown in Figure 2.
+
+![](images/727e86b2ef0470221fae2f43e47889a0ae8a621f009cf89078060a2777ebee3a.jpg)  
+Figure 2: (a) Illustration of the two networks which make up our meta auxiliary learning algorithm. (b) Illustration of vanilla SoftMax and Mask SoftMax with 3 principal classes. Vanilla SoftMax outputs over all 5 auxiliary classes, where as Mask Softmax outputs over a hierarchical structure $\psi \overset { = } { = } [ 2 , 2 , 1 ]$ to constrain the prediction space.
+
+# 3.2 MODEL OBJECTIVES
+
+The multi-task evaluator is trained in a tightly-coupled manner with the meta generator: the meta generator determines target labels for the multi-task evaluator, which in turn determines the suitability of those labels.
+
+Given target labels as determined by the meta generator, the multi-task evaluator is trained to predict these labels, alongside the ground-truth labels for the principal task. For both the principal and auxiliary classification tasks, we apply focal loss (Lin et al., 2017) with a focusing parameter $\gamma = 2$ , defined as:
+
+$$
+\mathcal { L } ( \hat { y } , y ) = - y ( 1 - \hat { y } ) ^ { \gamma } \log ( \hat { y } ) ,
+$$
+
+where $\hat { y }$ is the predicted label and $y$ is the ground-truth label. The focal loss helps to focus on the incorrectly predicted labels, which we found improved performance during our experimental evaluation compared with the regular cross-entropy log loss.
+
+To update parameters $\theta _ { 1 }$ in the multi-task evaluator, we define the multi-task objective as follows:
+
+$$
+\underset { \theta _ { 1 } } { \arg \operatorname* { m i n } } \left( \mathcal { L } ( f _ { \theta _ { 1 } } ^ { \mathrm { p r i } } ( x _ { \mathrm { t r a i n } } ^ { ( i ) } ) , y _ { \mathrm { t r a i n } } ^ { ( i ) } ) + \mathcal { L } ( f _ { \theta _ { 1 } } ^ { \mathrm { a u x } } ( x _ { \mathrm { t r a i n } } ^ { ( i ) } ) , g _ { \theta _ { 2 } } ^ { \mathrm { g e n } } ( x _ { \mathrm { t r a i n } } ^ { ( i ) } , y _ { \mathrm { t r a i n } } ^ { ( i ) } , \psi ) ) \right) \ ,
+$$
+
+where $( i )$ represents the $i ^ { t h }$ batch from the training data.
+
+The meta generator is then trained by encouraging target labels for the auxiliary task to be chosen such that, if the multi-task evaluator were to be trained on these labels, the performance on the principal task would be maximised. This requires evaluation on a separate dataset, the meta-training set, to train the meta generator, to ensure that the target auxiliary labels encourage generalisation beyond the data supplied to the multi-task evaluator.
+
+To update parameters $\theta _ { 2 }$ in the meta generator, we define the meta objective as follows:
+
+$$
+\underset { \theta _ { 2 } } { \arg \operatorname* { m i n } } \mathcal { L } ( f _ { \theta _ { 1 } ^ { + } } ^ { \mathrm { p r i } } ( x _ { \mathrm { m e t a } } ^ { ( i ) } ) , y _ { \mathrm { m e t a } } ^ { ( i ) } ) ~ .
+$$
+
+Here $\theta _ { 1 } ^ { + }$ represents the weights of the multi-task network were it to be trained, with one gradient update, using auxiliary labels $y _ { \mathrm { { m e t a } } }$ :
+
+$$
+\begin{array} { r } { \theta _ { 1 } ^ { + } = \theta _ { 1 } - \alpha \nabla _ { \theta _ { 1 } } \left( \mathcal { L } \big ( f _ { \theta _ { 1 } } ^ { \mathrm { p r i } } ( x _ { \mathrm { m e t a } } ^ { ( i ) } ) , y _ { \mathrm { m e t a } } ^ { ( i ) } \big ) + \mathcal { L } \big ( f _ { \theta _ { 1 } } ^ { \mathrm { a u x } } ( x _ { \mathrm { m e t a } } ^ { ( i ) } ) , g _ { \theta _ { 2 } } ^ { \mathrm { g e n } } ( x _ { \mathrm { m e t a } } ^ { ( i ) } , y _ { \mathrm { m e t a } } ^ { ( i ) } , \psi ) \Big ) \right) , } \end{array}
+$$
+
+where $\alpha$ is the learning rate.
+
+The trick in this meta objective is that we perform the derivative over a derivative (a Hessian matrix) to update $\theta _ { 2 }$ , by using a retained computational graph of $\theta _ { 1 } ^ { + }$ in order to compute derivatives with respect to $\theta _ { 2 }$ . This second derivative trick in meta learning was also proposed in Finn et al. (2017) and Zhang et al. (2018).
+
+However, we found that the generated auxiliary labels can easily collapse (i.e. degenerate by simply learning a similar level of complexity as the principal task), which leaves parameters $\theta _ { 2 }$ in a local minimum without producing any extra useful knowledge. Thus, to encourage the network to learn more complex and informative auxiliary tasks, we further apply an entropy loss $\mathcal { H } ( g _ { \theta _ { 2 } } ( x _ { \mathrm { m e t a } } ^ { ( i ) } , y _ { \mathrm { m e t a } } ^ { ( i ) } , \psi ) )$ as a regularisation term in the meta objective. A detailed explanation of the entropy loss and the collapsing label problem will be given in Section 3.4.
+
+Finally, the entire MAXL algorithm is defined as follows:
+
+# Algorithm 1: The MAXL algorithm
+
+Dataset: $D = \left\{ ( x _ { \mathrm { t r a i n } } , y _ { \mathrm { t r a i n } } ) , ( x _ { \mathrm { m e t a } } , y _ { \mathrm { m e t a } } ) \right\}$   
+Initialise: Network parameters: $\theta _ { 1 } , \theta _ { 2 }$ ; Hierarchical structure: $\psi$   
+Initialise: Hyper-parameter (learning rate): $\alpha , \beta$ ; Hyper-parameter (task weighting): $\lambda$   
+for each training iteration $i$ do $\left\{ \left( x _ { \mathrm { t r a i n } } ^ { ( i ) } , y _ { \mathrm { t r a i n } } ^ { ( i ) } \right) , \big ( x _ { \mathrm { m e t a } } ^ { ( i ) } , y _ { \mathrm { m e t a } } ^ { ( i ) } \big ) \right\} \in \left\{ \left( x _ { \mathrm { t r a i n } } , y _ { \mathrm { t r a i n } } \right) , \big ( x _ { \mathrm { m e t a } } , y _ { \mathrm { m e t a } } \big ) \right\}$ $\begin{array} { r } { \theta _ { 1 }  \theta _ { 1 } - \alpha \nabla _ { \theta _ { 1 } } ( \mathcal { L } \big ( f _ { \theta _ { 1 } } ^ { \mathrm { p i } } ( x _ { \mathrm { t r a i n } } ^ { ( i ) } ) , y _ { \mathrm { t r a i n } } ^ { ( i ) } \big ) + \mathcal { L } \big ( f _ { \theta _ { 1 } } ^ { \mathrm { a u x } } ( x _ { \mathrm { t r a i n } } ^ { ( i ) } ) , g _ { \theta _ { 2 } } ( x _ { \mathrm { t r a i n } } ^ { ( i ) } , y _ { \mathrm { t r a i n } } ^ { ( i ) } , \psi ) \Big )  } \end{array}$ # meta-training step Update: Compute $\begin{array} { r l } & { \theta _ { 1 } ^ { + } = \theta _ { 1 } ^ { ' } - \alpha \nabla _ { \theta _ { 1 } } ( \mathcal { L } ( f _ { \theta _ { 1 } } ^ { \mathrm { p i } } ( x _ { \mathrm { m e t a } } ^ { ( i ) } ) , y _ { \mathrm { m e t a } } ^ { ( i ) } ) + \mathcal { L } ( f _ { \theta _ { 1 } } ^ { \mathrm { a u x } } ( x _ { \mathrm { m e t a } } ^ { ( i ) } ) , g _ { \theta _ { 2 } } ( x _ { \mathrm { m e t a } } ^ { ( i ) } , y _ { \mathrm { m e t a } } ^ { ( i ) } , \psi ) ) } \\ & { \mathfrak { i } _ { 2 }  \theta _ { 2 } - \beta \nabla _ { \theta _ { 2 } } ( \mathcal { L } ( f _ { \theta _ { 1 } } ^ { \mathrm { p i } } ( x _ { \mathrm { m e t a } } ^ { ( i ) } ) , y _ { \mathrm { m e t a } } ^ { ( i ) } ) + \lambda \mathcal { H } ( g _ { \theta _ { 2 } } ^ { \mathrm { g e n } } ( x _ { \mathrm { m e t a } } ^ { ( i ) } , y _ { \mathrm { m e t a } } ^ { ( i ) } , \psi ) ) ) } \end{array}$   
+end
+
+# 3.3 MASK SOFTMAX FOR HIERARCHICAL PREDICTIONS
+
+In the prediction layer of the meta generator, we designed a modified SoftMax function to predict target auxiliary labels which conform to a pre-defined hierarchy $\psi$ . As shown in Figure 2 (upper right), the original softmax function does not constrain sub-class labelling to lie within this hierarchy. Our mask SoftMax structure resolves this issue by applying a binary mask to the original SoftMax function.
+
+The overall hierarchical structure $\psi$ determines the number of sub-classes $\psi [ i ]$ in each principal class $i$ . As such, the total prediction space for auxiliary labels is $\textstyle \sum _ { i } \psi [ i ]$ . This hierarchy, together with the ground-truth principal class label $y$ of the current image, creates the mask with a binarise function $\bar { \boldsymbol { M } } = \boldsymbol { B } ( \boldsymbol { y } , \bar { \boldsymbol { \psi } } )$ . Using the principal ground-truth label $y$ , the corresponding range of sub-classes $\psi [ y ]$ is selected, and a binary mask $M$ is created with size $\textstyle \sum _ { i } \psi [ i ]$ with a multi one-hot encoding $\begin{array} { r } { \mathbb { 1 } \sum _ { i < y } \psi [ i ] \colon \sum _ { i < y + 1 } \psi [ i ] } \end{array}$ $\scriptstyle \mathbf { 1 } _ { a : b }$ is denoted as a multi one-hot encoding in which indexes from $a$ to $b$ are encoded as 1).
+
+Using the example in Figure 2, consider the principal task to have 3 classes with ground truth labels $y = 0 , 1 , 2$ , and hierarchical structure $\psi \stackrel { - } { = } [ 2 , \stackrel { - } { 2 } , 1 ]$ . In this case, the auxiliary prediction space is equal to 5 and the corresponding binary masks are $M = [ 1 , 1 , 0 , 0 , 0 ] , [ 0 , 0 , 1 , 1 , 0 ] , [ 0 , 0 , 0 , 0 , 1 ]$ respectively.
+
+Finally, we apply binary mask $M$ with an element-wise multiplication on the original SoftMax function for the final auxiliary task predictions:
+
+$$
+p ( \hat { y } _ { i } ) = \frac { \exp \hat { y } _ { i } } { \sum _ { i } \exp \hat { y } _ { i } } , \qquad \mathrm { M a s k ~ S o f t M a x : } \quad p ( \hat { y } _ { i } ) = \frac { \exp M \odot \hat { y } _ { i } } { \sum _ { i } \exp M \odot \hat { y } _ { i } } , \quad M = \mathcal { B } ( y , \psi ) ,
+$$
+
+where $p ( \hat { y } _ { i } )$ represents the probability of the predicted principal label $\hat { y }$ over class $i$ , and $\odot$ represents element-wise multiplication.
+
+# 3.4 THE COLLAPSING CLASS PROBLEM
+
+As previously discussed, we predict each auxiliary label within a hierarchical structure $\psi$ . However, the number of sub-classes defined in $\psi [ i ]$ is the maximum auxiliary label prediction space, with no guarantee that all $\psi [ i ]$ classes will be predicted. This may result in some auxiliary labels defined in $\psi [ i ]$ being overlooked, with the output of the meta generator collapsing into a smaller sub-class space. In experiments, we found that this phenomenon is particularly apparent when we either have a large learning rate for training the meta generator, or a large sub-class prediction space $\psi$ .
+
+To avoid the collapsing class problem, we introduced an additional regularisation loss, which we call the entropy loss $\mathcal { H } ( \hat { y } ^ { ( i ) } )$ . This encourages the meta generator to utilise the full prediction space, by encouraging a large prediction entropy across this space.
+
+Assuming we have a well-balanced dataset, the entropy loss calculates the KL divergence between the predicted auxiliary label space $\hat { y } ^ { ( i ) }$ , and a uniform distribution $\mathcal { U }$ for each $i ^ { t h }$ batch. This is equivalent to calculating the entropy of the predicted label space, and is defined as:
+
+$$
+\mathcal { H } ( \hat { y } ^ { ( i ) } ) = \sum _ { k = 1 } ^ { K } \overline { { y _ { k } } } \log \overline { { y _ { k } } } , \quad \overline { { y _ { k } } } = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \hat { y } ^ { ( i ) } .
+$$
+
+where $K$ is the number of auxiliary labels and $N$ is the training batch size.
+
+The entropy loss is essential to achieve human-level performance, as shown in our experiments. The higher entropy in the auxiliary target labels results in a more complex auxiliary task. This avoids local minima during training, such as assigning a single label to all examples of a principal class.
+
+# 4 EXPERIMENTS
+
+In this section, we present experimental results to evaluate MAXL with respect to several baselines and datasets on image classification tasks.
+
+# 4.1 EXPERIMENTAL SETUP
+
+Datasets We evaluated on three different datasets: CIFAR100, CIFAR10, and CIFAR10.1v6 (Recht et al., 2018). CIFAR100 consists of 100 principal classes, whilst CIFAR10 and CIFAR10.1v6 consist of 10 principal classes and have the same training dataset as each other, but two different test datasets. To assess the generalisation across different task complexities, we tested a range of different combinations in the numbers of principal and auxiliary classes. For CIFAR100, we expanded the dataset’s provided 2-level hierarchy (20 and 100 classes) into a 4-level hierarchy (additional 3 and 10 classes), by manually assigning examples for these new hierarchy levels (see Appendix A). Based on the new hierarchy, we then tested on all 6 possible combinations of principal and auxiliary class numbers. Note that for MAXL, the hierarchy was used only to define the structure of $\psi$ and the principal task labels, to ensure a fair comparison with a method using human-defined auxiliary tasks, but the auxiliary task labelling within that structure was learned by MAXL itself. CIFAR10 and CIFAR10.1v6 do not have an associated manually-defined hierarchy, and so we defined a range of hierarchical structures $\psi [ i ] = 2 , 5 , 1 0 , 2 0 , 5 0 , 1 0 0 , \forall i$ .
+
+Baselines We compared MAXL to a number of baselines. Single Task trains only with the principal class label. Random Assignment trains with auxiliary classes, and randomly assigns the auxiliary class labels. Prototypical Net is a clustering method based on (Snell et al., 2017), where prototypes for auxiliary classes are defined by embedding examples from meta-training data, which has human-defined auxiliary classes, using a pre-trained ImageNet network. Unsupervised, differentiable, nearest-neighbour clustering is then used to produce the final auxiliary class labelling for the remaining training data. The key difference to MAXL is that, whilst both methods are unsupervised, the auxiliary class labelling with MAXL actually evaluates the generalisation performance of this labelling on the principal task, whilst the Prototypical Net method does not. Finally, Human trains with auxiliary classes, using the human-defined hierarchy. Note that due to the need for a manually-defined hierarchy, Prototypical Net and Human were only evaluated on CIFAR100. For all baselines, we use the same network architecture and training procedure as MAXL’s multi-task evaluator. For the meta-training for MAXL and Prototypical Net, we split each training dataset and used $10 \%$ for meta-training the auxiliary labelling, and $90 \%$ for training the multi-task evaluator. For all other baselines, we used the full training set for training the multi-task evaluator.
+
+Training For both the multi-task evaluator and the meta generator use VGG-16 as its core (Simonyan & Zisserman, 2014), together with batch normalisation. For all experiments, we used a learning rate of 0.01 for the multi-task evaluator. For MAXL’s meta generator, we found that a smaller learning rate of $1 0 ^ { - 5 }$ was necessary to help prevent the class collapsing problem. For all training, we drop the learning rate by half after every 50 epochs, and train for a total of 200 epochs, using vanilla stochastic gradient descent. For the meta generator, we apply an $L _ { 1 }$ norm weight decay of $5 \cdot 1 0 ^ { - 4 }$ on the meta generator, with no regularisation on the multi-task evaluator. We chose the weighting of the entropy regularisation loss term to be 0.2 based on empirical performance.
+
+# 4.2 TEST PERFORMANCE
+
+We now evaluate the performance of MAXL compared to these baselines, on all three datasets. Results for CIFAR100 are presented in Figure 3, and results for CIFAR10 and CIFAR10.1v6 are presented in Appendix B.
+
+![](images/ba3262f7dc28e5b4ee5046e70d3d7172a3449a226d32b38995b81556ee528b59.jpg)  
+Figure 3: Learning curves for the CIFAR100 test dataset, comparing MAXL with baseline methods. We provide results in all 6 different combinations of principal and auxiliary class numbers.
+
+For CIFAR100, we observe that MAXL performs similarly to when human knowledge is used in 4 out of the 6 hierarchical structures, and performs worse in 2 out of the 6. For all other baselines, MAXL performs at least as well, and in the majority of cases outperforms other baselines by a significant margin. We therefore see that MAXL is able to learn auxiliary tasks effectively by tightly coupling the auxiliary task generation and the principal task training, in a superior manner than when these auxiliary tasks are assigned independently, such as with random assignment or using prototypical net. With performance of MAXL approaching that of a system using a human-defined auxiliary tasks, we see strong evidence that MAXL is able to learn to generalise effectively in an unsupervised manner.
+
+# 4.3 EFFECT OF AUXILIARY TASK COMPLEXITY
+
+We now evaluate how the complexity of the auxiliary tasks affects the performance of the principal task. In Figure 4 (a), we present results from CIFAR10 and CIFAR10v1.6 showing the performance increase over single-task learning, when there are 10 principal classes, but a range of auxiliary class numbers $( \psi [ i ] \stackrel { } { = } 2 , 5 , 1 0 , 2 0 , 5 \bar { 0 } , 1 0 0 , \forall i )$ . For each data point, the performance is calculated by averaging the test accuracy from the last 5 epochs, after a total of 200 epochs. Experiments were performed both with and without the entropy loss term to show the benefit of this regularisation.
+
+We observe an interesting trend in which test performance rises as the number of auxiliary classes increases, but then begins to fall. This suggests that for a given complexity of principal task, there is an optimum complexity in the auxiliary tasks. One explanation for this may be that as the auxiliary tasks increase in complexity, the learned features favour learning these auxiliary tasks rather than the principal task, encouraging further generalisation beyond the features learned only for the principal task. But if the auxiliary task is too complex, then these features begin to overfit and lose the overlap between the reasoning required for the principal and auxiliary tasks, begins to decrease.
+
+![](images/6bc3b5c36a2651f5b22fd1f302e32729193f45fadac730c3aea84650018312cd.jpg)  
+Figure 4: Performance improvement in percentages when training with MAXL compared with single-task learning, with 10 principal classes and a range of auxiliary classes.
+
+# 4.4 VISUALISATIONS OF GENERATED KNOWLEDGE
+
+In Figure 5, we visualise 2D embeddings of examples from the CIFAR100 test dataset, on two different task complexities. This was computed using t-SNE (Maaten & Hinton, 2008) on the final feature layer of the multi-task evaluator, and compared across three methods: our MAXL method, our baseline using human-defined hierarchy, and our baseline using single-task learning.
+
+![](images/46a8f308f35fa53f6ad6b14f92ada0dc6d31c499ebea64196dceb57ec646934e.jpg)  
+Figure 5: t-SNE visualisation of the learned final layer of the multi-task evaluator network, trained with two combinations of principal and auxiliary class numbers from CIFAR100. Colours represent the principal classes.
+
+This visualisation shows the separability of principal classes after being trained with the multi-task evaluator. We see that both MAXL and Human show better separation of the principal classes than with Single-Task, owing to the generalisation effect of the auxiliary task learning. The distinction between the separability of the MAXL and Human visualisations is not as clear, despite their very similar performance for these two task complexities in Figure 3. But given that MAXL uses the same hierarchical structure as Human, we see from the visualisation that these two methods are clearly learning different representations.
+
+We also show examples of images assigned to the same auxiliary class through MAXL’s multi-task evaluator. Figure 6 shows example images with the highest prediction probabilities for three random auxiliary classes from CIFAR100, using the combination of 20 principal classes and 5 auxiliary classes per principal class, which showed the best performance of MAXL in Figure 3. In addition, we also applied MAXL to MNIST, in which 3 auxiliary classes were used for each of the 10 principal classes.
+
+![](images/0b1148d6aa97dee0e59d1c7049362ee17c4d34a79f73ca4fd59a1950a15f582f.jpg)  
+Figure 6: Visualisation of 5 test examples with the highest prediction probability, for each of 3 randomly selected auxiliary classes, for a number of different principal classes. We present the visualisation for CIFAR100 (top) when trained with 20 principal classes and 5 auxiliary classes per principal class, and for MNIST (bottom) when trained with 10 principal classes and 3 auxiliary classes per principal class.
+
+To our initial surprise, the generated auxiliary labels visualised in both datasets show no clear human-understandable knowledge. In particular, there are no obvious similarities within each auxiliary class whether in terms of shape, colour, style, structure or semantic meaning. However, this makes more sense when we re-consider the task of the meta generator, which is to assign auxiliary labels which assist the principal task. Rather than grouping images in terms of semantic or visual similarity, the meta generator would therefore be more effective it it were to group images in terms of a shared aspect of reasoning which the multi-task evaluator is currently facing difficulty on. If the multi-task evaluator is then able to improve its ability to determine the auxiliary class of an image in such a cluster, then the learned features will help in overcoming this challenging aspect of reasoning. It therefore makes sense that the examples within an auxiliary class do not share semantic or visual similarity, but instead share a more complex underlying property.
+
+Further, we discovered that the generated auxiliary knowledge is not deterministic, since the top predicted candidates are different when we re-train the network from scratch. We therefore speculate that using a human-defined hierarchy is just one out of a potentially infinite number of local optima, and on each run of training the meta generator produces another of these local optimums.
+
+# 5 CONCLUSION & FUTURE WORK
+
+In this paper, we have presented and evaluated Meta AuXiliary Learning (MAXL). MAXL learns to generate optimum auxiliary tasks which, when trained alongside a principal task in a multi-task setup, maximise the generalisation of the principal task across a validation dataset. Rather than employing domain knowledge and human-defined auxiliary tasks as is typically required, MAXL is self-supervised and, combined with its general nature, has the potential to automate the process of generalisation to new levels.
+
+Our evaluations on three image datasets have shown the performance of MAXL in an image classification setup, where the auxiliary task is to predict sub-class, hierarchical labels for an image. We have shown that MAXL significantly outperforms other auxiliary learning baselines, and even when human-defined knowledge is used to manually construct the auxiliary tasks, MAXL performs similarly in the majority of experiments.
+
+Despite this impressive performance from a self-supervised method, questioning why auxiliary tasks generated by MAXL do not outperform those constructed by a human opens exciting future research in this direction. Perhaps, human-defined auxiliary tasks are optimal themselves and cannot be surpassed. However, we believe this not to be the case since such tasks are typically chosen due to the availability of labelled data for these tasks, and not necessarily their optimality when combined with the principal task. Alternatively, perhaps the power of the human knowledge is not from the domain specific labels, but from higher-level reasoning about how auxiliary tasks should be structured. In our experiments, training MAXL using the same structure as a human-defined hierarchy, but learning its own auxiliary labels, typically led to similar performance as when the human-defined labels were used.
+
+The general nature of MAXL also opens up questions about how self-supervised auxiliary learning may be used to learn generic auxiliary tasks beyond sub-class labelling. During our experiments, we also ran preliminary experiments on predicting arbitrary vectors as the auxiliary task, but results so far have been inconclusive. However, the ability of MAXL to potentially learn flexible auxiliary tasks which can automatically be tuned for the principal task now offers an exciting direction towards automated generalisation across a wide range of more complex tasks.
+
+# REFERENCES
+
+Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, Brendan Shillingford, and Nando De Freitas. Learning to learn by gradient descent by gradient descent. In Advances in Neural Information Processing Systems, pp. 3981–3989, 2016.   
+Samy Bengio, Yoshua Bengio, Jocelyn Cloutier, and Jan Gecsei. On the optimization of a synaptic learning rule. In Preprints Conf. Optimality in Artificial and Biological Neural Networks, pp. 6–8. Univ. of Texas, 1992.   
+Yoshua Bengio, Samy Bengio, and Jocelyn Cloutier. Learning a synaptic learning rule. Universite´ de Montreal, D ´ epartement d’informatique et de recherche op ´ erationnelle, 1990. ´   
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. Ieee, 2009.   
+Carl Doersch and Andrew Zisserman. Multi-task self-supervised visual learning. In The IEEE International Conference on Computer Vision (ICCV), Oct 2017.   
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In International Conference on Machine Learning, pp. 1126–1135, 2017.   
+John Flynn, Ivan Neulander, James Philbin, and Noah Snavely. Deepstereo: Learning to predict new views from the world’s imagery. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5515–5524, 2016.   
+Max Jaderberg, Wojciech Marian Czarnecki, Simon Osindero, Oriol Vinyals, Alex Graves, David Silver, and Koray Kavukcuoglu. Decoupled neural interfaces using synthetic gradients. arXiv preprint arXiv:1608.05343, 2016.   
+Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. International Conference on Learning Representations, 2017.   
+Iasonas Kokkinos. Ubernet: Training a universal convolutional neural network for low-, mid-, and high-level vision using diverse datasets and limited memory. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.   
+Zhenguo Li, Fengwei Zhou, Fei Chen, and Hang Li. Meta-sgd: Learning to learn quickly for few shot learning. arXiv preprint arXiv:1707.09835, 2017.   
+Lukas Liebel and Marco Korner. Auxiliary tasks in multi-task learning. ¨ arXiv preprint arXiv:1805.06334, 2018.   
+Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense object ´ detection. arXiv preprint arXiv:1708.02002, 2017.   
+Shikun Liu, Edward Johns, and Andrew J Davison. End-to-end multi-task learning with attention. arXiv preprint arXiv:1803.10704, 2018.   
+Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of machine learning research, 9(Nov):2579–2605, 2008.   
+Ishan Misra, Abhinav Shrivastava, Abhinav Gupta, and Martial Hebert. Cross-stitch networks for multi-task learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3994–4003, 2016.   
+Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. 2016.   
+Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do cifar-10 classifiers generalize to cifar-10? arXiv preprint arXiv:1806.00451, 2018.   
+Sebastian Ruder. An overview of multi-task learning in deep neural networks. arXiv preprint arXiv:1706.05098, 2017.   
+Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy Lillicrap. Oneshot learning with memory-augmented neural networks. arXiv preprint arXiv:1605.06065, 2016.   
+Jurgen Schmidhuber. Learning complex, extended sequences using the principle of history com- ¨ pression. Neural Computation, 4(2):234–242, 1992.   
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.   
+Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Advances in Neural Information Processing Systems, pp. 4077–4087, 2017.   
+Shubham Toshniwal, Hao Tang, Liang Lu, and Karen Livescu. Multitask learning with low-level auxiliary tasks for encoder-decoder based speech recognition. arXiv preprint arXiv:1704.01631, 2017.   
+Oriol Vinyals, Charles Blundell, Tim Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In Advances in Neural Information Processing Systems, pp. 3630–3638, 2016.   
+Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Advances in neural information processing systems, pp. 3320–3328, 2014.   
+Yabin Zhang, Hui Tang, and Kui Jia. Fine-grained visual categorization using meta-learning optimization with sample selection of auxiliary data. arXiv preprint arXiv:1807.10916, 2018.   
+Tinghui Zhou, Matthew Brown, Noah Snavely, and David G Lowe. Unsupervised learning of depth and ego-motion from video. In CVPR, 2017.
+
+# A 4-LEVEL CIFAR100 DATASET
+
+Table 1: Building a 4-level hierarchy for image classification task based on CIFAR100 dataset. Originally, a 20-class and 100-class heirarchiy was provided, and we manually introduced a 3-class and 10 class layer.   
+
+<table><tr><td>3 Class</td><td>10 Class</td><td>20 Class</td><td>100 Class</td></tr><tr><td rowspan="10">animals</td><td rowspan="2">large animals</td><td>reptiles</td><td>crocodile,dinosaur,lizard,snake,turtle</td></tr><tr><td>large carnivores</td><td>bear,leopard, lion, tiger, wolf</td></tr><tr><td rowspan="2"></td><td></td><td>large omnivores and herbivores camel,catle,chimpanzee,elephant,kangaroo</td></tr><tr><td>aquatic mammals</td><td>beaver,dolphin,otter,seal, whale</td></tr><tr><td rowspan="2"></td><td>medium-sized mammals</td><td>fox,porcupine,possum, raccoon, skunk</td></tr><tr><td>small mammals</td><td>hamster,mouse,rabbit, shrew,squirrel</td></tr><tr><td rowspan="2"></td><td>fish</td><td>aquarium fish,flatfish,ray,shark,trout</td></tr><tr><td>insects</td><td>bee, beetle, butterfly,caterpillar,cockroach</td></tr><tr><td rowspan="2">people</td><td>non-insect invertebrates</td><td>crab,lobster,snail, spider, worm</td></tr><tr><td>people</td><td>baby,boy,girl,man,woman</td></tr><tr><td rowspan="3">vegetations</td><td rowspan="3">vegetations</td><td>flowers</td><td>orchids, poppies,roses,sunflowers,tulips</td></tr><tr><td>fruit and vegetables</td><td>apples,mushrooms,oranges, pears, peppers</td></tr><tr><td>trees</td><td>maple,oak,palm, pine,willow</td></tr><tr><td rowspan="7">objects and scenes construction</td><td rowspan="3"></td><td>food containers</td><td>bottles,bowls,cans,cups,plates</td></tr><tr><td>household objects household electrical devices</td><td>clock,keyboard,lamp,telephone,television</td></tr><tr><td>household furniture</td><td>bed,chair,couch,table,wardrobe</td></tr><tr><td></td><td>large man-made outdoor things</td><td>sbridge,castle,house,road,skyscraper</td></tr><tr><td>natural scenes</td><td>large natural outdoor scenes</td><td>cloud,forest, mountain, plain, sea</td></tr><tr><td rowspan="2">vehicles</td><td>vehicles 1</td><td>bicycle, bus, motorcycle,pickup truck, train</td></tr><tr><td>vehicles 2</td><td>lawn-mower, rocket, streetcar, tank, tractor</td></tr></table>
+
+# B LEARNING CURVES FOR CIFAR10/10.1V6
+
+![](images/5683941fcf7c15570684d5af976f175c72cd2f1ac4fcb778a27b828a724a25e3.jpg)  
+Figure 7: Testing performance on CIFAR10 (bottom) and CIFAR10.1v6 (top) datasets, across 6 different numbers of auxiliary classes.

parse/train/S1gd7nCcF7/S1gd7nCcF7_content_list.json

@@ -0,0 +1,1100 @@
+[
+    {
+        "type": "text",
+        "text": "SELF-SUPERVISED GENERALISATION WITH META AUXILIARY LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            694,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Auxiliary learning has been shown to improve the generalisation performance of a principal task. But typically, this requires manually-defined auxiliary tasks based on domain knowledge. In this paper, we consider that it may be possible to automatically learn these auxiliary tasks to best suit the principal task, towards optimum auxiliary tasks without any human knowledge. We propose a novel method, Meta Auxiliary Learning (MAXL), which we design for the task of image classification, where the auxiliary task is hierarchical sub-class image classification. The role of the meta learner is to determine sub-class target labels to train a multi-task evaluator, such that these labels improve the generalisation performance on the principal task. Experiments on three different CIFAR datasets show that MAXL outperforms baseline auxiliary learning methods, and is competitive even with a method which uses human-defined sub-class hierarchies. MAXL is self-supervised and general, and therefore offers a promising new direction towards automated generalisation. ",
+        "bbox": [
+            233,
+            262,
+            764,
+            454
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            478,
+            336,
+            493
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Auxiliary learning is a method to improve the generalisation of a task. It works by training on additional auxiliary tasks simultaneously with the principal task. Extra data may be available for those auxiliary tasks, but not the principal task. If the auxiliary tasks and the principal task share some common reasoning, then the prediction model is encouraged to learn additional relevant features which otherwise would not be learned from single-task learning. The broader support of these features then assists with generalisation of the principal task. ",
+        "bbox": [
+            174,
+            510,
+            823,
+            593
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We now rethink this generalisation by considering that not all auxiliary tasks are created equal. In supervised auxiliary learning (Liebel & Korner, 2018; Toshniwal et al., 2017), auxiliary tasks can be ¨ carefully chosen to complement the principal task, but at the expense of a dependency on labelled data. Unsupervised auxiliary learning (Flynn et al., 2016; Zhou et al., 2017; Zhang et al., 2018; Jaderberg et al., 2017) alleviates this, but at the expense of a limited set of auxiliary tasks which may not be well aligned with the principal task. By combining the merits of both supervised and unsupervised auxiliary learning, the ideal auxiliary learning framework is one with the flexibility to automatically determine the optimum auxiliary tasks, but without the requirement of any manuallylabelled data. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            727
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose to achieve such a framework with a simple and general meta-learning algorithm which we call Meta AuXiliary Learning (MAXL). Given a principal task, the goal of MAXL is to discover the auxiliary tasks which, when trained alongside the principal task, give the greatest generalisation performance of the principal task on a meta dataset. In our work, we focus on the problem of image classification, where an auxiliary task is required to assign a sub-class label to an image. As such, data is classified both at a coarse level as the principal task, and at a fine level as the auxiliary task. The meta learner’s role is then to determine the target labels for this sub-class labelling, in such a way that the learned features induced by learning these additional, more complex auxiliary tasks generate the best generalisation performance for the principal task. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            859
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As well as our method being able to automatically learn the optimum auxiliary tasks, we achieve this in an unsupervised manner, giving potential to scale well beyond any datasets without manuallylabelled auxiliary tasks, such as a class hierarchy as in our experiments. And even when such a hierarchy is available, in our experiments we show that MAXL is at least as competitive despite this hierarchy being learned in an unsupervised manner. In our experiments, we define the auxiliary tasks as sub-class labelling with MAXL learning to generate target sub-class labels, but MAXL is general and in future work this could be relaxed to actually learn the auxiliary tasks themselves. The ability to learn these tasks in a purely unsupervised and scalable manner opens up an exciting new way of thinking about how we can achieve generalisation in an automated manner. ",
+        "bbox": [
+            174,
+            868,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/9be7e47f76a69d61e122286e9e1ded5295110c346ed9a4f5ad2eac73b4c4eaa3.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of our proposed MAXL framework. The Multi-task evaluator takes an input image and is trained to predict both the principal class (e.g. Dog), and the auxiliary class (e.g. Border Collie). The principal class has a ground-truth label, but the label for the auxiliary class is determined by the meta generator. The meta generator is trained by outputting auxiliary class labels which, when used to train the multi-task evaluator, improve its prediction performance on the principal task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            185,
+            821,
+            383
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            510,
+            344,
+            526
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This work brings ideas together from a number of related areas of machine learning. ",
+        "bbox": [
+            176,
+            542,
+            723,
+            558
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Multi-task & Transfer Learning The aim of multi-task learning (MTL) is to achieve shared representations by simultaneously training a set of related learning tasks. In this case, the learned knowledge used to share across domains is encoded into the feature representations, to improve performance of each individual task, since knowledge distilled from related tasks are interdependent. The success of deep neural networks has led to some recent methods advancing the multi-task architecture design, such as applying a linear combination of task-specific features (Misra et al., 2016; Doersch & Zisserman, 2017; Kokkinos, 2017). Liu et al. (2018) applied soft-attention modules as feature selectors, allowing learning of both task-shared and task-specific features in a selfsupervised, end-to-end manner. Transfer learning is another common approach to improve generalisation, by incorporating knowledge learned from one or more related domains. Pre-training a model with a large-scale dataset such as ImageNet (Deng et al., 2009) has become standard practise in many vision-based applications. The transferability of different convolutional layers in CNNs has also been investigated in Yosinski et al. (2014). ",
+        "bbox": [
+            174,
+            574,
+            825,
+            753
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Auxiliary Learning Whilst in multi-task learning the goal is high test accuracy across all tasks, auxiliary learning differs in that high test accuracy is only required for a single principal task, and the role of the auxiliary tasks is to assist in generalisation of this principal task. Toshniwal et al. (2017) applied auxiliary supervision with phoneme recognition at intermediate low-level representations of deep networks to improve the performance of conversational speech recognition. Liebel & Korner ¨ (2018) chose auxiliary tasks which can be obtained with low effort, such as global descriptions of a scene, to boost the performance for single scene depth estimation and semantic segmentation. By carefully choosing a pair of learning tasks, we may also perform auxiliary learning without ground truth labels, in an unsupervised manner. Jaderberg et al. (2017) introduced a method for improving the learning agents in Atari games, by building unsupervised auxiliary tasks to predict the onset of immediate rewards from a short historical context. Flynn et al. (2016); Zhou et al. (2017) proposed image synthesis networks to perform unsupervised monocular depth estimation by predicting the relative pose of multiple cameras. Different from these works which require prior knowledge to manually define suitable auxiliary tasks, our proposed method requires no additional task knowledge, since our meta learner generates useful auxiliary knowledge in a purely unsupervised fashion. The most similar work to ours is Zhang et al. (2018), in which meta learning was used in auxiliary data selection. However, this still requires manually-labelled data from which these selections are made, whilst our method is able to generate auxiliary data from scratch. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Meta Learning Meta learning (or learning to learn) aims to design a higher-level learning system which itself is trained using the experiences of a lower-level learning system, in an attempt to improve this lower-level system. Early works in meta learning explored automatically learning update rules for neural models (Bengio et al., 1990; 1992; Schmidhuber, 1992). Recent approaches have focused on learning optimisers for deep networks based on LSTMs (Ravi & Larochelle, 2016) or synthetic gradients (Andrychowicz et al., 2016; Jaderberg et al., 2016). Meta learning has also been studied for finding optimal hyper-parameters (Li et al., 2017) and a good initialisation for few-shot learning (Finn et al., 2017). (Santoro et al., 2016) also investigated few shot learning via an external memory module. Vinyals et al. (2016); Snell et al. (2017) realised few shot learning in the instance space via a differentiable nearest-neighbour approach. Our method also performs in the instance space, but induces auxiliary knowledge as an implicit regularisation to improve generalisation of the principal task. ",
+        "bbox": [
+            174,
+            220,
+            825,
+            388
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 META AUXILIARY LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            414,
+            450,
+            430
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce our method for automatically generating optimum auxiliary tasks, which we call Meta AuXiliary Learning (MAXL). ",
+        "bbox": [
+            174,
+            449,
+            823,
+            478
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROBLEM SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            500,
+            333,
+            513
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The goal of meta auxiliary learning is to train a meta generator that can generate higher complexity auxiliary tasks, to improve performance of the principal task. To accomplish this, we use two networks: a multi-task evaluator which trains on the principal and auxiliary tasks, and evaluates the performance of the auxiliary tasks on a meta set, and a meta generator which generates these auxiliary tasks. For simplicity, we consider image classification tasks in this section, where the auxiliary task is sub-class labelling, and the meta generator determines target sub-class labels, but the approach can be considered general for any type of task. ",
+        "bbox": [
+            174,
+            529,
+            825,
+            626
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We denote the multi-task evaluator as a function $f _ { \\theta _ { 1 } } ( x )$ that takes an input $x$ with network parameters $\\theta _ { 1 }$ , and the meta generator as a function $g _ { \\theta _ { 2 } } ( x )$ that takes the same input $x$ with network parameters $\\theta _ { 2 }$ . For a dataset with input $x$ and ground-truth label $y$ for the principal task, we split into three subsets: training $( x _ { \\mathrm { t r a i n } } , y _ { \\mathrm { t r a i n } } )$ , meta-training $( x _ { \\mathrm { m e t a } } , y _ { \\mathrm { m e t a } } )$ , and test $( x _ { \\mathrm { t e s t } } , y _ { \\mathrm { t e s t } } )$ . Training data is used for updating $\\theta _ { 1 }$ , meta-training data is used for updating the $\\theta _ { 2 }$ , and test data is used for overall evaluation. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the multi-task evaluator, we apply a hard parameter sharing approach (Ruder, 2017) in which we predict the principal and auxiliary tasks using the shared set of features $\\theta _ { 1 }$ in the multi-task network. At the end of the last feature layer $f _ { \\theta _ { 1 } } ( x )$ , we then apply further task-specific layers to output the corresponding prediction for each task. We denote the predicted principal labels by $f _ { \\theta _ { 1 } } ^ { \\mathrm { p r i } } ( x )$ and predicted auxiliary labels by $f _ { \\theta _ { 1 } } ^ { \\mathrm { a u x } } ( x )$ . ",
+        "bbox": [
+            174,
+            728,
+            825,
+            805
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the meta generator, we pre-define a hierarchical structure $\\psi$ which determines the number of subclasses for each class in the principal task. At the end of the last feature layer $g _ { \\theta _ { 2 } } ( x )$ , this hierarchy, together with the ground-truth label $y$ for the principal task, are used to generate the target auxiliary labels, denoted by $g _ { \\theta _ { 2 } } ^ { \\mathrm { g e n } } ( x , y , \\psi )$ . We allow for soft assignment labelling rather than enforcing onehot encoding, which enables greater flexibility to learn optimum auxiliary tasks. The meta generator uses a masked SoftMax to ensure that each output node represents a sub-class label for only one class in the principal task, as described further in Section 3.3. The visualisation of the our proposed MAXL approach is shown in Figure 2. ",
+        "bbox": [
+            174,
+            811,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/727e86b2ef0470221fae2f43e47889a0ae8a621f009cf89078060a2777ebee3a.jpg",
+        "image_caption": [
+            "Figure 2: (a) Illustration of the two networks which make up our meta auxiliary learning algorithm. (b) Illustration of vanilla SoftMax and Mask SoftMax with 3 principal classes. Vanilla SoftMax outputs over all 5 auxiliary classes, where as Mask Softmax outputs over a hierarchical structure $\\psi \\overset { = } { = } [ 2 , 2 , 1 ]$ to constrain the prediction space. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            101,
+            812,
+            337
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 MODEL OBJECTIVES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            429,
+            359,
+            444
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The multi-task evaluator is trained in a tightly-coupled manner with the meta generator: the meta generator determines target labels for the multi-task evaluator, which in turn determines the suitability of those labels. ",
+        "bbox": [
+            173,
+            455,
+            825,
+            497
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given target labels as determined by the meta generator, the multi-task evaluator is trained to predict these labels, alongside the ground-truth labels for the principal task. For both the principal and auxiliary classification tasks, we apply focal loss (Lin et al., 2017) with a focusing parameter $\\gamma = 2$ , defined as: ",
+        "bbox": [
+            173,
+            503,
+            825,
+            559
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0a255aaf8e97891ed8eb4eca1f730fc8d8d6d199ea07301e047bfc92b8c52534.jpg",
+        "text": "$$\n\\mathcal { L } ( \\hat { y } , y ) = - y ( 1 - \\hat { y } ) ^ { \\gamma } \\log ( \\hat { y } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            559,
+            599,
+            577
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { y }$ is the predicted label and $y$ is the ground-truth label. The focal loss helps to focus on the incorrectly predicted labels, which we found improved performance during our experimental evaluation compared with the regular cross-entropy log loss. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            628
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To update parameters $\\theta _ { 1 }$ in the multi-task evaluator, we define the multi-task objective as follows: ",
+        "bbox": [
+            169,
+            635,
+            812,
+            650
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a46e0024cc6ea7929bc8527aa6c240bd5f300aec526cb9f4e2cb233518a1476a.jpg",
+        "text": "$$\n\\underset { \\theta _ { 1 } } { \\arg \\operatorname* { m i n } } \\left( \\mathcal { L } ( f _ { \\theta _ { 1 } } ^ { \\mathrm { p r i } } ( x _ { \\mathrm { t r a i n } } ^ { ( i ) } ) , y _ { \\mathrm { t r a i n } } ^ { ( i ) } ) + \\mathcal { L } ( f _ { \\theta _ { 1 } } ^ { \\mathrm { a u x } } ( x _ { \\mathrm { t r a i n } } ^ { ( i ) } ) , g _ { \\theta _ { 2 } } ^ { \\mathrm { g e n } } ( x _ { \\mathrm { t r a i n } } ^ { ( i ) } , y _ { \\mathrm { t r a i n } } ^ { ( i ) } , \\psi ) ) \\right) \\ ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            655,
+            728,
+            686
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $( i )$ represents the $i ^ { t h }$ batch from the training data. ",
+        "bbox": [
+            173,
+            702,
+            544,
+            718
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The meta generator is then trained by encouraging target labels for the auxiliary task to be chosen such that, if the multi-task evaluator were to be trained on these labels, the performance on the principal task would be maximised. This requires evaluation on a separate dataset, the meta-training set, to train the meta generator, to ensure that the target auxiliary labels encourage generalisation beyond the data supplied to the multi-task evaluator. ",
+        "bbox": [
+            173,
+            723,
+            826,
+            794
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To update parameters $\\theta _ { 2 }$ in the meta generator, we define the meta objective as follows: ",
+        "bbox": [
+            173,
+            800,
+            745,
+            815
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d6ed2aba8bf751fe6ef1017768eaddbd5869ecbc17625fafa91b01de51700de0.jpg",
+        "text": "$$\n\\underset { \\theta _ { 2 } } { \\arg \\operatorname* { m i n } } \\mathcal { L } ( f _ { \\theta _ { 1 } ^ { + } } ^ { \\mathrm { p r i } } ( x _ { \\mathrm { m e t a } } ^ { ( i ) } ) , y _ { \\mathrm { m e t a } } ^ { ( i ) } ) ~ .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            821,
+            598,
+            851
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here $\\theta _ { 1 } ^ { + }$ represents the weights of the multi-task network were it to be trained, with one gradient update, using auxiliary labels $y _ { \\mathrm { { m e t a } } }$ : ",
+        "bbox": [
+            169,
+            866,
+            825,
+            896
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0418d318a52594eb0ca1d682a0ba2db87984f75c33a411f4806a9414649a6044.jpg",
+        "text": "$$\n\\begin{array} { r } { \\theta _ { 1 } ^ { + } = \\theta _ { 1 } - \\alpha \\nabla _ { \\theta _ { 1 } } \\left( \\mathcal { L } \\big ( f _ { \\theta _ { 1 } } ^ { \\mathrm { p r i } } ( x _ { \\mathrm { m e t a } } ^ { ( i ) } ) , y _ { \\mathrm { m e t a } } ^ { ( i ) } \\big ) + \\mathcal { L } \\big ( f _ { \\theta _ { 1 } } ^ { \\mathrm { a u x } } ( x _ { \\mathrm { m e t a } } ^ { ( i ) } ) , g _ { \\theta _ { 2 } } ^ { \\mathrm { g e n } } ( x _ { \\mathrm { m e t a } } ^ { ( i ) } , y _ { \\mathrm { m e t a } } ^ { ( i ) } , \\psi ) \\Big ) \\right) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            901,
+            758,
+            929
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha$ is the learning rate. ",
+        "bbox": [
+            174,
+            103,
+            357,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The trick in this meta objective is that we perform the derivative over a derivative (a Hessian matrix) to update $\\theta _ { 2 }$ , by using a retained computational graph of $\\theta _ { 1 } ^ { + }$ in order to compute derivatives with respect to $\\theta _ { 2 }$ . This second derivative trick in meta learning was also proposed in Finn et al. (2017) and Zhang et al. (2018). ",
+        "bbox": [
+            174,
+            125,
+            825,
+            181
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "However, we found that the generated auxiliary labels can easily collapse (i.e. degenerate by simply learning a similar level of complexity as the principal task), which leaves parameters $\\theta _ { 2 }$ in a local minimum without producing any extra useful knowledge. Thus, to encourage the network to learn more complex and informative auxiliary tasks, we further apply an entropy loss $\\mathcal { H } ( g _ { \\theta _ { 2 } } ( x _ { \\mathrm { m e t a } } ^ { ( i ) } , y _ { \\mathrm { m e t a } } ^ { ( i ) } , \\psi ) )$ as a regularisation term in the meta objective. A detailed explanation of the entropy loss and the collapsing label problem will be given in Section 3.4. ",
+        "bbox": [
+            173,
+            188,
+            825,
+            275
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, the entire MAXL algorithm is defined as follows: ",
+        "bbox": [
+            174,
+            281,
+            550,
+            296
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: The MAXL algorithm ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            309,
+            415,
+            324
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Dataset: $D = \\left\\{ ( x _ { \\mathrm { t r a i n } } , y _ { \\mathrm { t r a i n } } ) , ( x _ { \\mathrm { m e t a } } , y _ { \\mathrm { m e t a } } ) \\right\\}$   \nInitialise: Network parameters: $\\theta _ { 1 } , \\theta _ { 2 }$ ; Hierarchical structure: $\\psi$   \nInitialise: Hyper-parameter (learning rate): $\\alpha , \\beta$ ; Hyper-parameter (task weighting): $\\lambda$   \nfor each training iteration $i$ do $\\left\\{ \\left( x _ { \\mathrm { t r a i n } } ^ { ( i ) } , y _ { \\mathrm { t r a i n } } ^ { ( i ) } \\right) , \\big ( x _ { \\mathrm { m e t a } } ^ { ( i ) } , y _ { \\mathrm { m e t a } } ^ { ( i ) } \\big ) \\right\\} \\in \\left\\{ \\left( x _ { \\mathrm { t r a i n } } , y _ { \\mathrm { t r a i n } } \\right) , \\big ( x _ { \\mathrm { m e t a } } , y _ { \\mathrm { m e t a } } \\big ) \\right\\}$ $\\begin{array} { r } { \\theta _ { 1 }  \\theta _ { 1 } - \\alpha \\nabla _ { \\theta _ { 1 } } ( \\mathcal { L } \\big ( f _ { \\theta _ { 1 } } ^ { \\mathrm { p i } } ( x _ { \\mathrm { t r a i n } } ^ { ( i ) } ) , y _ { \\mathrm { t r a i n } } ^ { ( i ) } \\big ) + \\mathcal { L } \\big ( f _ { \\theta _ { 1 } } ^ { \\mathrm { a u x } } ( x _ { \\mathrm { t r a i n } } ^ { ( i ) } ) , g _ { \\theta _ { 2 } } ( x _ { \\mathrm { t r a i n } } ^ { ( i ) } , y _ { \\mathrm { t r a i n } } ^ { ( i ) } , \\psi ) \\Big )  } \\end{array}$ # meta-training step Update: Compute $\\begin{array} { r l } & { \\theta _ { 1 } ^ { + } = \\theta _ { 1 } ^ { ' } - \\alpha \\nabla _ { \\theta _ { 1 } } ( \\mathcal { L } ( f _ { \\theta _ { 1 } } ^ { \\mathrm { p i } } ( x _ { \\mathrm { m e t a } } ^ { ( i ) } ) , y _ { \\mathrm { m e t a } } ^ { ( i ) } ) + \\mathcal { L } ( f _ { \\theta _ { 1 } } ^ { \\mathrm { a u x } } ( x _ { \\mathrm { m e t a } } ^ { ( i ) } ) , g _ { \\theta _ { 2 } } ( x _ { \\mathrm { m e t a } } ^ { ( i ) } , y _ { \\mathrm { m e t a } } ^ { ( i ) } , \\psi ) ) } \\\\ & { \\mathfrak { i } _ { 2 }  \\theta _ { 2 } - \\beta \\nabla _ { \\theta _ { 2 } } ( \\mathcal { L } ( f _ { \\theta _ { 1 } } ^ { \\mathrm { p i } } ( x _ { \\mathrm { m e t a } } ^ { ( i ) } ) , y _ { \\mathrm { m e t a } } ^ { ( i ) } ) + \\lambda \\mathcal { H } ( g _ { \\theta _ { 2 } } ^ { \\mathrm { g e n } } ( x _ { \\mathrm { m e t a } } ^ { ( i ) } , y _ { \\mathrm { m e t a } } ^ { ( i ) } , \\psi ) ) ) } \\end{array}$   \nend ",
+        "bbox": [
+            173,
+            328,
+            776,
+            531
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 MASK SOFTMAX FOR HIERARCHICAL PREDICTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            550,
+            581,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the prediction layer of the meta generator, we designed a modified SoftMax function to predict target auxiliary labels which conform to a pre-defined hierarchy $\\psi$ . As shown in Figure 2 (upper right), the original softmax function does not constrain sub-class labelling to lie within this hierarchy. Our mask SoftMax structure resolves this issue by applying a binary mask to the original SoftMax function. ",
+        "bbox": [
+            173,
+            575,
+            825,
+            646
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The overall hierarchical structure $\\psi$ determines the number of sub-classes $\\psi [ i ]$ in each principal class $i$ . As such, the total prediction space for auxiliary labels is $\\textstyle \\sum _ { i } \\psi [ i ]$ . This hierarchy, together with the ground-truth principal class label $y$ of the current image, creates the mask with a binarise function $\\bar { \\boldsymbol { M } } = \\boldsymbol { B } ( \\boldsymbol { y } , \\bar { \\boldsymbol { \\psi } } )$ . Using the principal ground-truth label $y$ , the corresponding range of sub-classes $\\psi [ y ]$ is selected, and a binary mask $M$ is created with size $\\textstyle \\sum _ { i } \\psi [ i ]$ with a multi one-hot encoding $\\begin{array} { r } { \\mathbb { 1 } \\sum _ { i < y } \\psi [ i ] \\colon \\sum _ { i < y + 1 } \\psi [ i ] } \\end{array}$ $\\scriptstyle \\mathbf { 1 } _ { a : b }$ is denoted as a multi one-hot encoding in which indexes from $a$ to $b$ are encoded as 1). ",
+        "bbox": [
+            173,
+            652,
+            825,
+            753
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using the example in Figure 2, consider the principal task to have 3 classes with ground truth labels $y = 0 , 1 , 2$ , and hierarchical structure $\\psi \\stackrel { - } { = } [ 2 , \\stackrel { - } { 2 } , 1 ]$ . In this case, the auxiliary prediction space is equal to 5 and the corresponding binary masks are $M = [ 1 , 1 , 0 , 0 , 0 ] , [ 0 , 0 , 1 , 1 , 0 ] , [ 0 , 0 , 0 , 0 , 1 ]$ respectively. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            816
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, we apply binary mask $M$ with an element-wise multiplication on the original SoftMax function for the final auxiliary task predictions: ",
+        "bbox": [
+            176,
+            821,
+            823,
+            852
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b16eb9b12692bf95db03b4553b36b920a8d628786fe877849ce784ecd3550ff3.jpg",
+        "text": "$$\np ( \\hat { y } _ { i } ) = \\frac { \\exp \\hat { y } _ { i } } { \\sum _ { i } \\exp \\hat { y } _ { i } } , \\qquad \\mathrm { M a s k ~ S o f t M a x : } \\quad p ( \\hat { y } _ { i } ) = \\frac { \\exp M \\odot \\hat { y } _ { i } } { \\sum _ { i } \\exp M \\odot \\hat { y } _ { i } } , \\quad M = \\mathcal { B } ( y , \\psi ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            240,
+            856,
+            823,
+            891
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $p ( \\hat { y } _ { i } )$ represents the probability of the predicted principal label $\\hat { y }$ over class $i$ , and $\\odot$ represents element-wise multiplication. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 THE COLLAPSING CLASS PROBLEM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            462,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As previously discussed, we predict each auxiliary label within a hierarchical structure $\\psi$ . However, the number of sub-classes defined in $\\psi [ i ]$ is the maximum auxiliary label prediction space, with no guarantee that all $\\psi [ i ]$ classes will be predicted. This may result in some auxiliary labels defined in $\\psi [ i ]$ being overlooked, with the output of the meta generator collapsing into a smaller sub-class space. In experiments, we found that this phenomenon is particularly apparent when we either have a large learning rate for training the meta generator, or a large sub-class prediction space $\\psi$ . ",
+        "bbox": [
+            174,
+            128,
+            825,
+            214
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To avoid the collapsing class problem, we introduced an additional regularisation loss, which we call the entropy loss $\\mathcal { H } ( \\hat { y } ^ { ( i ) } )$ . This encourages the meta generator to utilise the full prediction space, by encouraging a large prediction entropy across this space. ",
+        "bbox": [
+            174,
+            220,
+            825,
+            265
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Assuming we have a well-balanced dataset, the entropy loss calculates the KL divergence between the predicted auxiliary label space $\\hat { y } ^ { ( i ) }$ , and a uniform distribution $\\mathcal { U }$ for each $i ^ { t h }$ batch. This is equivalent to calculating the entropy of the predicted label space, and is defined as: ",
+        "bbox": [
+            174,
+            271,
+            825,
+            315
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d1157113428b0d17c6103bd08003e616355d20ed8f36571b36eea736d2c7f733.jpg",
+        "text": "$$\n\\mathcal { H } ( \\hat { y } ^ { ( i ) } ) = \\sum _ { k = 1 } ^ { K } \\overline { { y _ { k } } } \\log \\overline { { y _ { k } } } , \\quad \\overline { { y _ { k } } } = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\hat { y } ^ { ( i ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            321,
+            648,
+            366
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $K$ is the number of auxiliary labels and $N$ is the training batch size. ",
+        "bbox": [
+            176,
+            371,
+            661,
+            387
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The entropy loss is essential to achieve human-level performance, as shown in our experiments. The higher entropy in the auxiliary target labels results in a more complex auxiliary task. This avoids local minima during training, such as assigning a single label to all examples of a principal class. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            435
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            457,
+            326,
+            472
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present experimental results to evaluate MAXL with respect to several baselines and datasets on image classification tasks. ",
+        "bbox": [
+            173,
+            488,
+            823,
+            516
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            534,
+            375,
+            549
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets We evaluated on three different datasets: CIFAR100, CIFAR10, and CIFAR10.1v6 (Recht et al., 2018). CIFAR100 consists of 100 principal classes, whilst CIFAR10 and CIFAR10.1v6 consist of 10 principal classes and have the same training dataset as each other, but two different test datasets. To assess the generalisation across different task complexities, we tested a range of different combinations in the numbers of principal and auxiliary classes. For CIFAR100, we expanded the dataset’s provided 2-level hierarchy (20 and 100 classes) into a 4-level hierarchy (additional 3 and 10 classes), by manually assigning examples for these new hierarchy levels (see Appendix A). Based on the new hierarchy, we then tested on all 6 possible combinations of principal and auxiliary class numbers. Note that for MAXL, the hierarchy was used only to define the structure of $\\psi$ and the principal task labels, to ensure a fair comparison with a method using human-defined auxiliary tasks, but the auxiliary task labelling within that structure was learned by MAXL itself. CIFAR10 and CIFAR10.1v6 do not have an associated manually-defined hierarchy, and so we defined a range of hierarchical structures $\\psi [ i ] = 2 , 5 , 1 0 , 2 0 , 5 0 , 1 0 0 , \\forall i$ . ",
+        "bbox": [
+            173,
+            560,
+            825,
+            741
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines We compared MAXL to a number of baselines. Single Task trains only with the principal class label. Random Assignment trains with auxiliary classes, and randomly assigns the auxiliary class labels. Prototypical Net is a clustering method based on (Snell et al., 2017), where prototypes for auxiliary classes are defined by embedding examples from meta-training data, which has human-defined auxiliary classes, using a pre-trained ImageNet network. Unsupervised, differentiable, nearest-neighbour clustering is then used to produce the final auxiliary class labelling for the remaining training data. The key difference to MAXL is that, whilst both methods are unsupervised, the auxiliary class labelling with MAXL actually evaluates the generalisation performance of this labelling on the principal task, whilst the Prototypical Net method does not. Finally, Human trains with auxiliary classes, using the human-defined hierarchy. Note that due to the need for a manually-defined hierarchy, Prototypical Net and Human were only evaluated on CIFAR100. For all baselines, we use the same network architecture and training procedure as MAXL’s multi-task evaluator. For the meta-training for MAXL and Prototypical Net, we split each training dataset and used $10 \\%$ for meta-training the auxiliary labelling, and $90 \\%$ for training the multi-task evaluator. For all other baselines, we used the full training set for training the multi-task evaluator. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Training For both the multi-task evaluator and the meta generator use VGG-16 as its core (Simonyan & Zisserman, 2014), together with batch normalisation. For all experiments, we used a learning rate of 0.01 for the multi-task evaluator. For MAXL’s meta generator, we found that a smaller learning rate of $1 0 ^ { - 5 }$ was necessary to help prevent the class collapsing problem. For all training, we drop the learning rate by half after every 50 epochs, and train for a total of 200 epochs, using vanilla stochastic gradient descent. For the meta generator, we apply an $L _ { 1 }$ norm weight decay of $5 \\cdot 1 0 ^ { - 4 }$ on the meta generator, with no regularisation on the multi-task evaluator. We chose the weighting of the entropy regularisation loss term to be 0.2 based on empirical performance. ",
+        "bbox": [
+            174,
+            162,
+            825,
+            273
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 TEST PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            292,
+            362,
+            306
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now evaluate the performance of MAXL compared to these baselines, on all three datasets. Results for CIFAR100 are presented in Figure 3, and results for CIFAR10 and CIFAR10.1v6 are presented in Appendix B. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            361
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ba3262f7dc28e5b4ee5046e70d3d7172a3449a226d32b38995b81556ee528b59.jpg",
+        "image_caption": [
+            "Figure 3: Learning curves for the CIFAR100 test dataset, comparing MAXL with baseline methods. We provide results in all 6 different combinations of principal and auxiliary class numbers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            376,
+            818,
+            641
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For CIFAR100, we observe that MAXL performs similarly to when human knowledge is used in 4 out of the 6 hierarchical structures, and performs worse in 2 out of the 6. For all other baselines, MAXL performs at least as well, and in the majority of cases outperforms other baselines by a significant margin. We therefore see that MAXL is able to learn auxiliary tasks effectively by tightly coupling the auxiliary task generation and the principal task training, in a superior manner than when these auxiliary tasks are assigned independently, such as with random assignment or using prototypical net. With performance of MAXL approaching that of a system using a human-defined auxiliary tasks, we see strong evidence that MAXL is able to learn to generalise effectively in an unsupervised manner. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            823
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 EFFECT OF AUXILIARY TASK COMPLEXITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            840,
+            513,
+            854
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now evaluate how the complexity of the auxiliary tasks affects the performance of the principal task. In Figure 4 (a), we present results from CIFAR10 and CIFAR10v1.6 showing the performance increase over single-task learning, when there are 10 principal classes, but a range of auxiliary class numbers $( \\psi [ i ] \\stackrel { } { = } 2 , 5 , 1 0 , 2 0 , 5 \\bar { 0 } , 1 0 0 , \\forall i )$ . For each data point, the performance is calculated by averaging the test accuracy from the last 5 epochs, after a total of 200 epochs. Experiments were performed both with and without the entropy loss term to show the benefit of this regularisation. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We observe an interesting trend in which test performance rises as the number of auxiliary classes increases, but then begins to fall. This suggests that for a given complexity of principal task, there is an optimum complexity in the auxiliary tasks. One explanation for this may be that as the auxiliary tasks increase in complexity, the learned features favour learning these auxiliary tasks rather than the principal task, encouraging further generalisation beyond the features learned only for the principal task. But if the auxiliary task is too complex, then these features begin to overfit and lose the overlap between the reasoning required for the principal and auxiliary tasks, begins to decrease. ",
+        "bbox": [
+            173,
+            140,
+            825,
+            238
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6bc3b5c36a2651f5b22fd1f302e32729193f45fadac730c3aea84650018312cd.jpg",
+        "image_caption": [
+            "Figure 4: Performance improvement in percentages when training with MAXL compared with single-task learning, with 10 principal classes and a range of auxiliary classes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            257,
+            720,
+            382
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 VISUALISATIONS OF GENERATED KNOWLEDGE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            453,
+            544,
+            467
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 5, we visualise 2D embeddings of examples from the CIFAR100 test dataset, on two different task complexities. This was computed using t-SNE (Maaten & Hinton, 2008) on the final feature layer of the multi-task evaluator, and compared across three methods: our MAXL method, our baseline using human-defined hierarchy, and our baseline using single-task learning. ",
+        "bbox": [
+            174,
+            481,
+            825,
+            537
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/46a8f308f35fa53f6ad6b14f92ada0dc6d31c499ebea64196dceb57ec646934e.jpg",
+        "image_caption": [
+            "Figure 5: t-SNE visualisation of the learned final layer of the multi-task evaluator network, trained with two combinations of principal and auxiliary class numbers from CIFAR100. Colours represent the principal classes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            551,
+            812,
+            664
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This visualisation shows the separability of principal classes after being trained with the multi-task evaluator. We see that both MAXL and Human show better separation of the principal classes than with Single-Task, owing to the generalisation effect of the auxiliary task learning. The distinction between the separability of the MAXL and Human visualisations is not as clear, despite their very similar performance for these two task complexities in Figure 3. But given that MAXL uses the same hierarchical structure as Human, we see from the visualisation that these two methods are clearly learning different representations. ",
+        "bbox": [
+            173,
+            734,
+            825,
+            832
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also show examples of images assigned to the same auxiliary class through MAXL’s multi-task evaluator. Figure 6 shows example images with the highest prediction probabilities for three random auxiliary classes from CIFAR100, using the combination of 20 principal classes and 5 auxiliary classes per principal class, which showed the best performance of MAXL in Figure 3. In addition, we also applied MAXL to MNIST, in which 3 auxiliary classes were used for each of the 10 principal classes. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0b1148d6aa97dee0e59d1c7049362ee17c4d34a79f73ca4fd59a1950a15f582f.jpg",
+        "image_caption": [
+            "Figure 6: Visualisation of 5 test examples with the highest prediction probability, for each of 3 randomly selected auxiliary classes, for a number of different principal classes. We present the visualisation for CIFAR100 (top) when trained with 20 principal classes and 5 auxiliary classes per principal class, and for MNIST (bottom) when trained with 10 principal classes and 3 auxiliary classes per principal class. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            104,
+            818,
+            450
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To our initial surprise, the generated auxiliary labels visualised in both datasets show no clear human-understandable knowledge. In particular, there are no obvious similarities within each auxiliary class whether in terms of shape, colour, style, structure or semantic meaning. However, this makes more sense when we re-consider the task of the meta generator, which is to assign auxiliary labels which assist the principal task. Rather than grouping images in terms of semantic or visual similarity, the meta generator would therefore be more effective it it were to group images in terms of a shared aspect of reasoning which the multi-task evaluator is currently facing difficulty on. If the multi-task evaluator is then able to improve its ability to determine the auxiliary class of an image in such a cluster, then the learned features will help in overcoming this challenging aspect of reasoning. It therefore makes sense that the examples within an auxiliary class do not share semantic or visual similarity, but instead share a more complex underlying property. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            715
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Further, we discovered that the generated auxiliary knowledge is not deterministic, since the top predicted candidates are different when we re-train the network from scratch. We therefore speculate that using a human-defined hierarchy is just one out of a potentially infinite number of local optima, and on each run of training the meta generator produces another of these local optimums. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            780
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION & FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            805,
+            472,
+            820
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have presented and evaluated Meta AuXiliary Learning (MAXL). MAXL learns to generate optimum auxiliary tasks which, when trained alongside a principal task in a multi-task setup, maximise the generalisation of the principal task across a validation dataset. Rather than employing domain knowledge and human-defined auxiliary tasks as is typically required, MAXL is self-supervised and, combined with its general nature, has the potential to automate the process of generalisation to new levels. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our evaluations on three image datasets have shown the performance of MAXL in an image classification setup, where the auxiliary task is to predict sub-class, hierarchical labels for an image. We have shown that MAXL significantly outperforms other auxiliary learning baselines, and even when human-defined knowledge is used to manually construct the auxiliary tasks, MAXL performs similarly in the majority of experiments. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            172
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Despite this impressive performance from a self-supervised method, questioning why auxiliary tasks generated by MAXL do not outperform those constructed by a human opens exciting future research in this direction. Perhaps, human-defined auxiliary tasks are optimal themselves and cannot be surpassed. However, we believe this not to be the case since such tasks are typically chosen due to the availability of labelled data for these tasks, and not necessarily their optimality when combined with the principal task. Alternatively, perhaps the power of the human knowledge is not from the domain specific labels, but from higher-level reasoning about how auxiliary tasks should be structured. In our experiments, training MAXL using the same structure as a human-defined hierarchy, but learning its own auxiliary labels, typically led to similar performance as when the human-defined labels were used. ",
+        "bbox": [
+            174,
+            181,
+            825,
+            319
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The general nature of MAXL also opens up questions about how self-supervised auxiliary learning may be used to learn generic auxiliary tasks beyond sub-class labelling. During our experiments, we also ran preliminary experiments on predicting arbitrary vectors as the auxiliary task, but results so far have been inconclusive. However, the ability of MAXL to potentially learn flexible auxiliary tasks which can automatically be tuned for the principal task now offers an exciting direction towards automated generalisation across a wide range of more complex tasks. ",
+        "bbox": [
+            174,
+            327,
+            825,
+            410
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            431,
+            285,
+            446
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, Brendan Shillingford, and Nando De Freitas. Learning to learn by gradient descent by gradient descent. In Advances in Neural Information Processing Systems, pp. 3981–3989, 2016.   \nSamy Bengio, Yoshua Bengio, Jocelyn Cloutier, and Jan Gecsei. On the optimization of a synaptic learning rule. In Preprints Conf. Optimality in Artificial and Biological Neural Networks, pp. 6–8. Univ. of Texas, 1992.   \nYoshua Bengio, Samy Bengio, and Jocelyn Cloutier. Learning a synaptic learning rule. Universite´ de Montreal, D ´ epartement d’informatique et de recherche op ´ erationnelle, 1990. ´   \nJia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. Ieee, 2009.   \nCarl Doersch and Andrew Zisserman. Multi-task self-supervised visual learning. In The IEEE International Conference on Computer Vision (ICCV), Oct 2017.   \nChelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In International Conference on Machine Learning, pp. 1126–1135, 2017.   \nJohn Flynn, Ivan Neulander, James Philbin, and Noah Snavely. Deepstereo: Learning to predict new views from the world’s imagery. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5515–5524, 2016.   \nMax Jaderberg, Wojciech Marian Czarnecki, Simon Osindero, Oriol Vinyals, Alex Graves, David Silver, and Koray Kavukcuoglu. Decoupled neural interfaces using synthetic gradients. arXiv preprint arXiv:1608.05343, 2016.   \nMax Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. International Conference on Learning Representations, 2017.   \nIasonas Kokkinos. Ubernet: Training a universal convolutional neural network for low-, mid-, and high-level vision using diverse datasets and limited memory. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.   \nZhenguo Li, Fengwei Zhou, Fei Chen, and Hang Li. Meta-sgd: Learning to learn quickly for few shot learning. arXiv preprint arXiv:1707.09835, 2017.   \nLukas Liebel and Marco Korner. Auxiliary tasks in multi-task learning. ¨ arXiv preprint arXiv:1805.06334, 2018.   \nTsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense object ´ detection. arXiv preprint arXiv:1708.02002, 2017.   \nShikun Liu, Edward Johns, and Andrew J Davison. End-to-end multi-task learning with attention. arXiv preprint arXiv:1803.10704, 2018.   \nLaurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of machine learning research, 9(Nov):2579–2605, 2008.   \nIshan Misra, Abhinav Shrivastava, Abhinav Gupta, and Martial Hebert. Cross-stitch networks for multi-task learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3994–4003, 2016.   \nSachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. 2016.   \nBenjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do cifar-10 classifiers generalize to cifar-10? arXiv preprint arXiv:1806.00451, 2018.   \nSebastian Ruder. An overview of multi-task learning in deep neural networks. arXiv preprint arXiv:1706.05098, 2017.   \nAdam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy Lillicrap. Oneshot learning with memory-augmented neural networks. arXiv preprint arXiv:1605.06065, 2016.   \nJurgen Schmidhuber. Learning complex, extended sequences using the principle of history com- ¨ pression. Neural Computation, 4(2):234–242, 1992.   \nKaren Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.   \nJake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Advances in Neural Information Processing Systems, pp. 4077–4087, 2017.   \nShubham Toshniwal, Hao Tang, Liang Lu, and Karen Livescu. Multitask learning with low-level auxiliary tasks for encoder-decoder based speech recognition. arXiv preprint arXiv:1704.01631, 2017.   \nOriol Vinyals, Charles Blundell, Tim Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In Advances in Neural Information Processing Systems, pp. 3630–3638, 2016.   \nJason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Advances in neural information processing systems, pp. 3320–3328, 2014.   \nYabin Zhang, Hui Tang, and Kui Jia. Fine-grained visual categorization using meta-learning optimization with sample selection of auxiliary data. arXiv preprint arXiv:1807.10916, 2018.   \nTinghui Zhou, Matthew Brown, Noah Snavely, and David G Lowe. Unsupervised learning of depth and ego-motion from video. In CVPR, 2017. ",
+        "bbox": [
+            169,
+            449,
+            826,
+            929
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            85,
+            828,
+            797
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A 4-LEVEL CIFAR100 DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            462,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/9f61b436c49056f3b3628d53b40e15f6daf2662e3105bb8695f2c20959bc81b7.jpg",
+        "table_caption": [
+            "Table 1: Building a 4-level hierarchy for image classification task based on CIFAR100 dataset. Originally, a 20-class and 100-class heirarchiy was provided, and we manually introduced a 3-class and 10 class layer. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>3 Class</td><td>10 Class</td><td>20 Class</td><td>100 Class</td></tr><tr><td rowspan=\"10\">animals</td><td rowspan=\"2\">large animals</td><td>reptiles</td><td>crocodile,dinosaur,lizard,snake,turtle</td></tr><tr><td>large carnivores</td><td>bear,leopard, lion, tiger, wolf</td></tr><tr><td rowspan=\"2\"></td><td></td><td>large omnivores and herbivores camel,catle,chimpanzee,elephant,kangaroo</td></tr><tr><td>aquatic mammals</td><td>beaver,dolphin,otter,seal, whale</td></tr><tr><td rowspan=\"2\"></td><td>medium-sized mammals</td><td>fox,porcupine,possum, raccoon, skunk</td></tr><tr><td>small mammals</td><td>hamster,mouse,rabbit, shrew,squirrel</td></tr><tr><td rowspan=\"2\"></td><td>fish</td><td>aquarium fish,flatfish,ray,shark,trout</td></tr><tr><td>insects</td><td>bee, beetle, butterfly,caterpillar,cockroach</td></tr><tr><td rowspan=\"2\">people</td><td>non-insect invertebrates</td><td>crab,lobster,snail, spider, worm</td></tr><tr><td>people</td><td>baby,boy,girl,man,woman</td></tr><tr><td rowspan=\"3\">vegetations</td><td rowspan=\"3\">vegetations</td><td>flowers</td><td>orchids, poppies,roses,sunflowers,tulips</td></tr><tr><td>fruit and vegetables</td><td>apples,mushrooms,oranges, pears, peppers</td></tr><tr><td>trees</td><td>maple,oak,palm, pine,willow</td></tr><tr><td rowspan=\"7\">objects and scenes construction</td><td rowspan=\"3\"></td><td>food containers</td><td>bottles,bowls,cans,cups,plates</td></tr><tr><td>household objects household electrical devices</td><td>clock,keyboard,lamp,telephone,television</td></tr><tr><td>household furniture</td><td>bed,chair,couch,table,wardrobe</td></tr><tr><td></td><td>large man-made outdoor things</td><td>sbridge,castle,house,road,skyscraper</td></tr><tr><td>natural scenes</td><td>large natural outdoor scenes</td><td>cloud,forest, mountain, plain, sea</td></tr><tr><td rowspan=\"2\">vehicles</td><td>vehicles 1</td><td>bicycle, bus, motorcycle,pickup truck, train</td></tr><tr><td>vehicles 2</td><td>lawn-mower, rocket, streetcar, tank, tractor</td></tr></table>",
+        "bbox": [
+            184,
+            191,
+            810,
+            584
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B LEARNING CURVES FOR CIFAR10/10.1V6 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            566,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/5683941fcf7c15570684d5af976f175c72cd2f1ac4fcb778a27b828a724a25e3.jpg",
+        "image_caption": [
+            "Figure 7: Testing performance on CIFAR10 (bottom) and CIFAR10.1v6 (top) datasets, across 6 different numbers of auxiliary classes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            131,
+            820,
+            689
+        ],
+        "page_idx": 12
+    }
+]

parse/train/rkgbYyHtwB/rkgbYyHtwB.md

@@ -0,0 +1,424 @@
+# DISAGREEMENT-REGULARIZED IMITATION LEARNING
+
+Kiante Brantley ´ ∗ University of Maryland kdbrant@cs.umd.edu
+
+Wen Sun Microsoft Research sun.wen@microsoft.com
+
+Mikael Henaff Microsoft Research mihenaff@microsoft.com
+
+# ABSTRACT
+
+We present a simple and effective algorithm designed to address the covariate shift problem in imitation learning. It operates by training an ensemble of policies on the expert demonstration data, and using the variance of their predictions as a cost which is minimized with RL together with a supervised behavioral cloning cost. Unlike adversarial imitation methods, it uses a fixed reward function which is easy to optimize. We prove a regret bound for the algorithm which is linear in the time horizon multiplied by a coefficient which we show to be low for certain problems on which behavioral cloning fails. We evaluate our algorithm empirically across multiple pixel-based Atari environments and continuous control tasks, and show that it matches or significantly outperforms behavioral cloning and generative adversarial imitation learning.
+
+# 1 INTRODUCTION
+
+Training artificial agents to perform complex tasks is essential for many applications in robotics, video games and dialogue. If success on the task can be accurately described using a reward or cost function, reinforcement learning (RL) methods offer an approach to learning policies which has proven to be successful in a wide variety of applications (Mnih et al., 2015; 2016; Lillicrap et al., 2016; Hessel et al., 2018). However, in other cases the desired behavior may only be roughly specified and it is unclear how to design a reward function to characterize it. For example, training a video game agent to adopt more human-like behavior using RL would require designing a reward function which characterizes behaviors as more or less human-like, which is difficult.
+
+Imitation learning (IL) offers an elegant approach whereby agents are trained to mimic the demonstrations of an expert rather than optimizing a reward function. Its simplest form consists of training a policy to predict the expert’s actions from states in the demonstration data using supervised learning. While appealingly simple, this approach suffers from the fact that the distribution over states observed at execution time can differ from the distribution observed during training. Minor errors which initially produce small deviations become magnified as the policy encounters states further and further from its training distribution. This phenomenon, initially noted in the early work of (Pomerleau, 1989), was formalized in the work of (Ross & Bagnell, 2010) who proved a quadratic $\mathcal { O } ( \epsilon T ^ { 2 } )$ bound on the regret and showed that this bound is tight. The subsequent work of (Ross et al., 2011) showed that if the policy is allowed to further interact with the environment and make queries to the expert policy, it is possible to obtain a linear bound on the regret. However, the ability to query an expert can often be a strong assumption.
+
+In this work, we propose a new and simple algorithm called DRIL (Disagreement-Regularized Imitation Learning) to address the covariate shift problem in imitation learning, in the setting where the agent is allowed to interact with its environment. Importantly, the algorithm does not require any additional interaction with the expert. It operates by training an ensemble of policies on the demonstration data, and using the disagreement in their predictions as a cost which is optimized through RL together with a supervised behavioral cloning cost. The motivation is that the policies in the ensemble will tend to agree on the set of states covered by the expert, leading to low cost, but are more likely to disagree on states not covered by the expert, leading to high cost. The RL cost thus guides the agent back towards the distribution of the expert, while the supervised cost ensures that it mimics the expert within the expert’s distribution.
+
+Our theoretical results show that, subject to realizability and optimization oracle assumptions1, our algorithm obtains a $\mathcal { O } ( \epsilon \kappa T )$ regret bound, where $\kappa$ is a measure which quantifies a tradeoff between the concentration of the demonstration data and the diversity of the ensemble outside the demonstration data. We evaluate DRIL empirically across multiple pixel-based Atari environments and continuous control tasks, and show that it matches or significantly outperforms behavioral cloning and generative adversarial imitation learning, often recovering expert performance with only a few trajectories.
+
+# 2 PRELIMINARIES
+
+We consider episodic finite horizon MDP in this work. Denote by $s$ the state space, $\mathcal { A }$ the action space, and $\Pi$ the class of policies the learner is considering. Let $T$ denote the task horizon and $\pi ^ { \star }$ the expert policy whose behavior the learner is trying to mimic. For any policy $\pi$ , let $d _ { \pi }$ denote the distribution over states induced by following $\pi$ . Denote $C ( s , a )$ the expected immediate cost of performing action $a$ in state $s$ , which we assume is bounded in [0, 1]. In the imitation learning setting, we do not necessarily know the true costs $C ( s , a )$ , and instead we observe expert demonstrations. Our goal is to find a policy $\pi$ which minimizes an observed surrogate loss $\ell$ between its actions and the actions of the expert under its induced distribution of states, i.e.
+
+$$
+\hat { \pi } = \arg \operatorname* { m i n } \mathbb { E } _ { s \sim d _ { \pi } } [ \ell ( \pi ( s ) , \pi ^ { \star } ( s ) ) ]
+$$
+
+For the following, we will assume $\ell$ is the total variation distance (denoted by $\| \cdot \| )$ , which is an upper bound on the $0 - 1$ loss. Our goal is thus to minimize the following quantity, which represents the distance between the actions taken by our policy $\pi$ and the expert policy $\pi ^ { \star }$ :
+
+$$
+J _ { \exp } ( \pi ) = \mathbb { E } _ { s \sim d _ { \pi } } \Big [ \| \pi ( \cdot | s ) - \pi ^ { \star } ( \cdot | s ) \| \Big ]
+$$
+
+Denote $\begin{array} { r } { \mathbb { E } \left[ \sum _ { \tau = t } ^ { T } C ( s _ { \tau } , a _ { \tau } ) | ( s _ { t } , a _ { t } ) = ( s , a ) , a _ { \tau } \sim \pi \right] } \end{array}$ $Q _ { t } ^ { \pi } ( s , a )$ as the standard Q-function of the policy . The following result shows that if $\pi$ , which is defined as $\ell$ $Q _ { t } ^ { \pi } ( s , a ) \ =$ is an upper bound on the $0 - 1$ loss and $C$ satisfies certain smoothness conditions, then minimizing this loss within $\epsilon$ translates into an $\mathcal { O } ( \epsilon T )$ regret bound on the true task cost $J _ { \mathrm { C } } ( \pi ) = \mathbb { E } _ { s , a \sim d _ { \pi } } [ C ( \bar { s } , a ) ]$ :
+
+Theorem 1. (Ross et al., 2011) If $\pi$ satisfies $J _ { \mathrm { e x p } } ( \pi ) = \epsilon _ { \mathrm { : } }$ , and $Q _ { T - t + 1 } ^ { \pi ^ { \star } } ( s , a ) - Q _ { T - t + 1 } ^ { \pi ^ { \star } } ( s , \pi ^ { \star } ) \leq u$ for all time steps $t$ , actions a and states s reachable by $\pi$ , then $J _ { \mathrm { C } } ( \pi ) \le J _ { \mathrm { C } } ( \pi ^ { \star } ) + u T \epsilon$ .
+
+Unfortunately, it is often not possible to optimize $J _ { \exp }$ directly, since it requires evaluating the expert policy on the states induced by following the current policy. The supervised behavioral cloning cost $J _ { \mathrm { B C } }$ , which is computed on states induced by the expert, is often used instead:
+
+$$
+J _ { \mathrm { B C } } ( \pi ) = \mathbb { E } _ { s \sim d _ { \pi ^ { \star } } } [ \| \pi ^ { \star } ( \cdot | s ) - \pi ( \cdot | s ) \| ]
+$$
+
+Minimizing this loss within $\epsilon$ yields a quadratic regret bound on regret:
+
+Theorem 2. (Ross & Bagnell, 2010) Let $J _ { \mathrm { B C } } ( \pi ) = \epsilon ,$ then $J _ { \mathrm { C } } ( \pi ) \leq J _ { \mathrm { C } } ( \pi ^ { \star } ) + T ^ { 2 } \epsilon .$
+
+Furthermore, this bound is tight: as we will discuss later, there exist simple problems which match the worst-case lower bound.
+
+# 3 ALGORITHM
+
+Our algorithm is motivated by two criteria: i) the policy should act similarly to the expert within the expert’s data distribution, and ii) the policy should move towards the expert’s data distribution
+
+1: Input: Expert demonstration data $\mathcal { D } = \{ ( s _ { i } , a _ { i } ) \} _ { i = 1 } ^ { N }$   
+2: Initialize policy $\pi$ and policy ensemble $\Pi _ { \mathrm { E } } = \{ \pi _ { 1 } , . . . , \pi _ { E } \}$   
+3: for $e = 1 , E$ do   
+4: Sample $\mathcal { D } _ { e } \sim \mathcal { D }$ with replacement, with $| \mathcal { D } _ { e } | = | \mathcal { D } |$ .   
+5: Train $\pi _ { e }$ to minimize $J _ { \mathrm { B C } } ( \pi _ { e } )$ on $\mathcal { D } _ { e }$ to convergence.   
+6: end for   
+7: for $i = 1 , \dots$ do   
+8: Perform one gradient update to minimize $J _ { \mathrm { B C } } ( \pi )$ using a minibatch from $\mathcal { D }$ .   
+9: Perform one step of policy gradient to minimize $\mathbb { E } _ { s \sim d _ { \pi } , a \sim \pi ( \cdot | s ) } [ C _ { \mathrm { U } } ^ { \mathrm { c l i p } } ( s , a ) ]$ .   
+10: end for
+
+if it is outside of it. These two criteria are addressed by combining two losses: a standard behavior cloning loss, and an additional loss which represents the variance over the outputs of an ensemble $\Pi _ { \mathrm { E } } = \mathbf { \bar { \Pi } } \{ \pi _ { 1 } , . . . , \pi _ { E } \}$ of policies trained on the demonstration data $\mathcal { D }$ . We call this the uncertainty cost, which is defined as:
+
+$$
+C _ { \mathrm { U } } ( s , a ) = \mathrm { V a r } _ { \pi \sim \Pi _ { \mathrm { E } } } ( \pi ( a | s ) ) = \frac { 1 } { E } \sum _ { i = 1 } ^ { E } \left( \pi _ { i } ( a | s ) - \frac { 1 } { E } \sum _ { i = 1 } ^ { E } \pi _ { i } ( a | s ) \right) ^ { 2 }
+$$
+
+The motivation is that the variance over plausible policies is high outside the expert’s distribution, since the data is sparse, but it is low inside the expert’s distribution, since the data there is dense. Minimizing this cost encourages the policy to return to regions of dense coverage by the expert. Intuitively, this is what we would expect the expert policy $\pi ^ { \star }$ to do as well. The total cost which the algorithm optimizes is given by:
+
+$$
+\begin{array} { r } { J _ { \mathrm { { a l g } } } ( \pi ) = \underbrace { { \mathbb { E } } _ { s \sim d _ { \pi ^ { \star } } } \left[ | | \pi ^ { \star } ( \cdot | s ) - \pi ( \cdot | s ) | | \right] } _ { J _ { \mathrm { { B C } } } ( \pi ) } + \underbrace { { \mathbb { E } } _ { s \sim d _ { \pi } , a \sim \pi ( \cdot | s ) } \left[ C _ { \mathrm { U } } ( s , a ) \right] } _ { J _ { \mathrm { { U } } } ( \pi ) } } \end{array}
+$$
+
+The first term is a behavior cloning loss and is computed over states generated by the expert policy, of which the demonstration data $\mathcal { D }$ is a representative sample. The second term is computed over the distribution of states generated by the current policy and can be optimized using policy gradient.
+
+Note that the demonstration data is fixed, and this ensemble can be trained once offline. We then interleave the supervised behavioral cloning updates and the policy gradient updates which minimize the variance of the ensemble. The full algorithm is shown in Algorithm 1. We also found that dropout (Srivastava et al., 2014), which has been proposed as an approximate form of ensembling, worked well (see Appendix D).
+
+In practice, for the supervised loss we optimize the KL divergence between the actions predicted by the policy and the expert actions, which is an upper bound on the total variation distance due to Pinsker’s inequality. We also found it helpful to use a clipped uncertainty cost:
+
+$$
+C _ { \mathrm { U } } ^ { \mathrm { c l i p } } ( s , a ) = { \left\{ \begin{array} { l l } { - 1 } & { { \mathrm { i f } } \ C _ { \mathrm { U } } ( s , a ) \leq q } \\ { + 1 } & { { \mathrm { e l s e } } } \end{array} \right. }
+$$
+
+where the threshold $q$ is a top quantile of the raw uncertainty costs computed over the demonstration data. The threshold $q$ defines a normal range of uncertainty based on the demonstration data, and values above this range incur a positive cost (or negative reward).
+
+The RL cost can be optimized using any policy gradient method. In our experiments we used advantage actor-critic (A2C) (Mnih et al., 2016) or PPO (Schulman et al., 2017), which estimate the expected cost using rollouts from multiple parallel actors all sharing the same policy (see Appendix C for details). We note that model-based RL methods could in principle be used as well if sample efficiency is a constraint.
+
+# 4 ANALYSIS
+
+# 4.1 COVERAGE COEFFICIENT
+
+We now analyze DRIL for MDPs with discrete action spaces and potentially large or infinite state spaces. We will show that, subject to assumptions that the policy class contains an optimal policy and that we are able to optimize costs within $\epsilon$ of their global minimum, our algorithm obtains a regret bound which is linear in $\kappa T$ , where $\kappa$ is a quantity which depends on the environment dynamics, the expert distribution $d _ { \pi } ^ { \star }$ , and our learned ensemble. Intuitively, $\kappa$ represents a tradeoff between how concentrated the demonstration data is and how high the variance of the ensemble is outside the expert distribution.
+
+Assumption 1. (Realizability) $\pi ^ { \star } \in \Pi$
+
+Assumption 2. (Optimization Oracle) For any given cost function $J$ , our minimization procedure returns a policy ${ \hat { \pi } } \in \Pi$ such that $J ( \widehat { \pi } ) \leq \arg \operatorname* { m i n } _ { \pi \in \Pi } J ( \pi ) + \epsilon .$ .
+
+The motivation behind our algorithm is that the policies in the ensemble agree inside the expert’s distribution and disagree outside of it. This defines a reward function which pushes the learner back towards the expert’s distribution if it strays away. However, what constitutes inside and outside the distribution, or sufficient agreement or disagreement, is ambiguous. Below we introduce quantities which makes these ideas precise.
+
+Definition 1. For any set $\begin{array} { r l r } { \mathcal { U } } & { { } \subseteq } & { S } \end{array}$ , define the concentrability inside of $\mathcal { U }$ as $\begin{array} { r l } { \alpha ( \mathcal { U } ) } & { { } = } \end{array}$ $\begin{array} { r } { \operatorname* { m a x } _ { \pi \in \Pi } \operatorname* { s u p } _ { s \in \mathcal { U } } \frac { d _ { \pi } ( s ) } { d _ { \pi ^ { \star } ( s ) } } } \end{array}$
+
+The notion of concentrability has been previously used to give bounds on the performance of value iteration (Munos & Szepesvari, 2008). For a set ´ $\mathcal { U }$ , $\alpha ( \mathcal { U } )$ will be low if the expert distribution has high mass at the states in $\mathcal { U }$ that are reachable by policies in the policy class.
+
+Definition 2. Define the minimum variance of the ensemble outside of $\mathcal { U }$ as $\begin{array} { r l } { \beta ( \mathcal { U } ) } & { { } = } \end{array}$ $\begin{array} { r } { \operatorname* { m i n } _ { s \not \in \mathcal { U } , a \in \mathcal { A } } \operatorname { V a r } _ { \pi \sim \Pi _ { \mathrm { E } } } [ \pi ( a | s ) ] } \end{array}$ .
+
+We now define the $\kappa$ coefficient as the minimum ratio of these two quantities over all possible subsets of $s$ .
+
+Definition 3. We define κ = minU⊆S α(U)β(U) .
+
+We can view $\kappa$ as the quantity which minimizes the tradeoff over different subsets $\mathcal { U }$ between coverage by the expert policy inside of $\mathcal { U }$ , and variance of the ensemble outside of $\mathcal { U }$ .
+
+# 4.2 REGRET BOUND
+
+We now establish a relationship between the $\kappa$ coefficient just defined, the cost our algorithm optimizes, and $J _ { \mathrm { e x p } }$ defined in Equation (2) which we would ideally like to minimize and which translates into a regret bound. All proofs can be found in Appendix A.
+
+Lemma 1. For any $\pi \in \Pi$ , we have $J _ { \mathrm { e x p } } ( \pi ) \le \kappa J _ { \mathrm { a l g } } ( \pi )$ .
+
+This result shows that if $\kappa$ is not too large, and we are able to make our cost function $J _ { \mathrm { a l g } } ( \pi )$ small, then we can ensure $J _ { \exp } ( \pi )$ is also small. This result is only useful if our cost function can indeed achieve a small minimum. The next lemma shows that this is the case.
+
+Lemma 2. $\begin{array} { r } { \operatorname* { m i n } _ { \pi \in \Pi } J _ { \mathrm { a l g } } ( \pi ) \le 2 \epsilon } \end{array}$ .
+
+Here $\epsilon$ is the threshold specified in Assumption 2. Combining these two lemmas with the previous result of Ross et al. (2011), we get a regret bound which is linear in $\kappa T$ .
+
+Theorem 3. Let πˆ be the result of minimizing $J _ { \mathrm { a l g } }$ using our optimization oracle, and assume that $Q _ { T - t + 1 } ^ { \pi ^ { \star } } ( s , a ) - Q _ { T - t + 1 } ^ { \pi ^ { \star } } ( s , \pi ^ { \star } ) \leq u$ for all actions $a$ , time steps $t$ and states s reachable by $\pi$ . Then $\hat { \pi }$ satisfies $J _ { \scriptscriptstyle \mathrm { C } } ( \hat { \pi } ) \leq J _ { \scriptscriptstyle \mathrm { C } } ( \pi ^ { \star } ) + 3 u \kappa \epsilon T$ .
+
+Our bound is an improvement over that of behavior cloning if $\kappa$ is less than $\mathcal { O } ( T )$ . Note that DRIL does not require knowledge of $\kappa$ . The quantity $\kappa$ is problem-dependent and depends on the environment dynamics, the expert policy and the policies in the learned ensemble. We next compute $\kappa$ exactly for a problem for which behavior cloning is known to perform poorly, and show that it is independent of $T$ .
+
+![](images/68e4a2dec40b01d14eecadff2090a4ffad0c8c08dd4e6d1606d486e68d71db80.jpg)  
+Figure 1: Example of a problem where behavioral cloning incurs quadratic regret.
+
+Example 1. Consider the tabular MDP given in (Ross & Bagnell, 2010) as an example of a problem where behavioral cloning incurs quadratic regret, shown in Figure 1. There are $^ 3$ states $\boldsymbol { S } = \left( { { s _ { 0 } } , { s _ { 1 } } , { s _ { 2 } } } \right)$ and two actions $( a _ { 1 } , \underset { - } { a _ { 2 } } )$ . Each policy $\pi$ can be represented as a set of probabilities $\pi ( a _ { 1 } | s )$ for each state $s \in S ^ { \ 2 }$ . Assume the models in our ensemble are drawn from a posterior $p ( \pi ( a _ { 1 } | s ) | \mathcal { D } )$ given by a Beta distribution with parameters $B e t a ( n _ { 1 } + 1 , n _ { 2 } + 1 )$ where $n _ { 1 } , n _ { 2 }$ are the number of times the pairs $( s , a _ { 1 } )$ and $( s , a _ { 2 } )$ occur, respectively, in the demonstration data $\mathcal { D }$ . The agent always starts in $s _ { 0 }$ and the expert’s policy is given by $\pi ^ { \star } ( a _ { 1 } | s _ { 0 } ) =$ $1 , \pi ^ { \star } ( a _ { 1 } | s _ { 1 } ) = 0 , \pi ^ { \star } ( a _ { 1 } | s _ { 2 } ) = 1$ . For any $( s , a )$ pair, the task cost is $C ( s , a ) = 0$ if $a = \pi ^ { \star } ( s )$ and 1 otherwise. Here $\begin{array} { r } { d _ { \pi } ^ { \star } \ = \ ( \frac { 1 } { T } , \frac { T - 1 } { T } , 0 ) } \end{array}$ . For any $\pi$ , $\begin{array} { r } { d _ { \pi } ( s _ { 0 } ) \ = \ \frac { 1 } { T } } \end{array}$ and $\begin{array} { r } { d _ { \pi } ( s _ { 1 } ) \ \leq \ \frac { T - 1 } { T } } \end{array}$ due to the dynamics of the MDP, so $\begin{array} { r } { \frac { d _ { \pi } ( s ) } { d _ { \pi } ^ { \star } ( s ) } \le 1 } \end{array}$ for $s \in \{ s _ { 0 } , s _ { 1 } \}$ . Writing out $\alpha ( \{ s _ { 0 } , s _ { 1 } \} )$ , we get: $\begin{array} { r } { \alpha ( \{ s _ { 0 } , s _ { 1 } \} ) = \operatorname* { m a x } _ { \pi \in \Pi } \operatorname* { s u p } _ { s \in \{ s _ { 0 } , s _ { 1 } \} } \frac { d _ { \pi } ( s ) } { d _ { \pi } ^ { \star } ( s ) } \le 1 . } \end{array}$
+
+Furthermore, since $s _ { 2 }$ is never visited in the demonstration data, for each policy $\pi _ { i }$ in the ensemble we have $\pi _ { i } ( a _ { 1 } | s _ { 2 } ) , \pi _ { i } ( a _ { 2 } | s _ { 2 } ) \sim B e t a ( 1 , 1 ) = U n i f o r m ( 0 , 1 )$ . It follows that $\mathrm { V a r } _ { \pi \sim \Pi _ { \mathrm { E } } } ( \pi ( a | s _ { 2 } ) )$ is approximately equal 3 to the variance of a uniform distribution over $[ 0 , 1 ]$ , i.e. $\textstyle { \frac { 1 } { 1 2 } }$ . Therefore:
+
+$$
+\kappa = \operatorname* { m i n } _ { \mathcal { U } \subseteq \mathcal { S } } \frac { \alpha ( \mathcal { U } ) } { \beta ( \mathcal { U } ) } \leq \frac { \alpha ( \{ s _ { 0 } , s _ { 1 } \} ) } { \beta ( \{ s _ { 0 } , s _ { 1 } \} ) } \lesssim \frac { 1 } { \frac { 1 } { 1 2 } } = 1 2
+$$
+
+Applying our result from Theorem 3, we see that our algorithm obtains an $\mathcal { O } ( \epsilon T )$ regret bound on this problem, in contrast to the $\mathcal { O } ( \epsilon T ^ { 2 } )$ regret of behavioral cloning4.
+
+# 5 RELATED WORK
+
+The idea of learning through imitation dates back at least to the work of (Pomerleau, 1989), who trained a neural network to imitate the steering actions of a human driver using images as input. The problem of covariate shift was already observed, as the author notes: “the network must not solely be shown examples of accurate driving, but also how to recover once a mistake has been made”.
+
+This issue was formalized in the work of (Ross & Bagnell, 2010), who on one hand proved an $\mathcal { O } ( \epsilon T ^ { 2 } )$ regret bound, and on the other hand provided an example showing this bound is tight. The subsequent work (Ross et al., 2011) proposed the DAGGER algorithm which obtains linear regret, provided the agent can both interact with the environment, and query the expert policy. Our approach also requires environment interaction, but importantly does not need to query the expert. Also of note is the work of (Venkatraman et al., 2015), which extended DAGGER to time series prediction problems by using the true targets as expert corrections.
+
+Imitation learning has been used within the context of modern RL to help improve sample efficiency (Chang et al., 2015; Ross & Bagnell, 2014; Sun et al., 2017; Hester et al., 2018; Le et al., 2018; Cheng & Boots, 2018) or overcome exploration (Nair et al., 2017). These settings assume the reward is known and that the policies can then be fine-tuned with reinforcement learning. In this case, covariate shift is less of an issue since it can be corrected using the reinforcement signal.
+
+The work of (Luo et al., 2019) also proposed a method to address the covariate shift problem when learning from demonstrations when the reward is known, by conservatively extrapolating the value function outside the training distribution using negative sampling. This addresses a different setting from ours, and requires generating plausible states which are off the manifold of training data, which may be challenging when the states are high dimensional such as images. The work of (Reddy et al., 2019) proposed to treat imitation learning within the Q-learning framework, setting a positive reward for all transitions inside the demonstration data and zero reward for all other transitions in the replay buffer. This rewards the agent for repeating (or returning to) the expert’s transitions. The work of (Sasaki et al., 2019) also incorporates a mechanism for reducing covariate shift by fitting a Q-function that classifies whether the demonstration states are reachable from the current state. Random Expert Distillation (Wang et al., 2019) uses Random Network Distillation (RND) (Burda et al., 2019) to estimate the support of the expert’s distribution in state-action space, and minimizes an RL cost designed to guide the agent towards the expert’s support. This is related to our method, but differs in that it minimizes the RND prediction error rather than the ensemble variance and does not include a behavior cloning cost. The behavior cloning cost is essential to our theoretical results and avoids certain failure modes, see Appendix B for more discusion.
+
+Generative Adversarial Imitation Learning (GAIL) (Ho & Ermon, 2016) is a state-of-the-art algorithm which addresses the same setting as ours. It operates by training a discriminator network to distinguish expert states from states generated by the current policy, and the negative output of the discriminator is used as a reward signal to train the policy. The motivation is that states which are outside the training distribution will be assigned a low reward while states which are close to it will be assigned a high reward. This encourages the policy to return to the expert distribution if it strays away from it. However, the adversarial training procedure means that the reward function is changing over time, which can make the algorithm unstable or difficult to tune. In contrast, our approach uses a simple fixed reward function. We include comparisons to GAIL in our experiments.
+
+Using disagreement between models in an ensemble to represent uncertainty has recently been explored in several contexts. The works of (Shyam et al., 2018; Pathak et al., 2019; Henaff, 2019) used disagreement between different dynamics models to drive exploration in the context of modelbased RL. Conversely, (Henaff et al., 2019) used variance across different dropout masks to prevent policies from exploiting error in dynamics models. Ensembles have also been used to represent uncertainty over Q-values in model-free RL in order to encourage exploration (Osband et al., 2016). Within the context of imitation learning, the work of (Menda et al., 2018) used the variance of the ensemble together with the DAGGER algorithm to decide when to query the expert demonstrator to minimize unsafe situations. Here, we use disagreement between different policies trained on demonstration data to address covariate shift in the context of imitation learning.
+
+# 6 EXPERIMENTS
+
+# 6.1 TABULAR MDPS
+
+As a first experiment, we applied DRIL to the tabular MDP of (Ross & Bagnell, 2010) shown in Figure 1. We computed the posterior over the policy parameters given the demonstration data using a separate Beta distribution for each state $s$ with parameters determined by the number of times each action was performed in s. For behavior cloning, we sampled a single policy from this posterior. For DRIL, we sampled an ensemble of 5 policies and used their negative variance to define an additional reward function. We combined this with a reward which was the probability density function of a given state-action pair under the posterior distribution, which corresponds to the supervised learning loss, and used tabular Q-learning to optimize the sum of these two reward functions. This experiment was repeated 500 times for time horizon lengths up to 500 and $N = 1 , 5 , 1 0$ expert demonstration trajectories.
+
+![](images/2493ce67dfd3a36789481b8ea016ce3a998184660878b9d06f5905f8bf05413a.jpg)  
+Figure 2: Results on tabular MDP from (Ross & Bagnell, 2010). Shaded region represents range between $5 ^ { \mathrm { t h } }$ and $9 5 ^ { \mathrm { t h } }$ quantiles, computed across 500 trials. Behavior cloning exhibits poor worstcase regret, whereas DRIL has low regret across all trials.
+
+Figure 2 shows plots of the regret over the 500 different trials across different time horizons. Although BC achieves good average performance, it exhibits poor worst-case performance with some trials incurring very high regret, especially when using fewer demonstrations. Our method has low regret across all trials, which stays close to constant independantly of the time horizon, even with a single demonstration. This performance is better than that suggested by our analysis, which showed a worst-case linear bound with respect to time horizon.
+
+# 6.2 ATARI ENVIRONMENTS
+
+We next evaluated our approach on six different Atari environments. We used pretrained PPO (Schulman et al., 2017) agents from the stable baselines repository (Hill et al., 2018) to generate $N = \{ 1 , 3 , 5 , 1 0 , 1 5 , 2 0 \}$ expert trajectories. We compared against two other methods: standard behavioral cloning (BC) and Generative Adversarial Imitation Learning (GAIL). Results are shown in Figure 3a. DRIL outperforms behavioral cloning across most environments and numbers of demonstrations, often by a substantial margin. In many cases, our method is able to match the expert’s performance using a small number of trajectories. Figure 3b shows the evolution of the uncertainty cost and the policy reward throughout training. In all cases, the reward improves while the uncertainty cost decreases.
+
+We were not able to obtain meaningful performance for GAIL on these domains, despite performing a hyperparameter search across learning rates for the policy and discriminator, and across different numbers of discriminator updates. We additionally experimented with clipping rewards in an effort to stabilize performance. These results are consistent with those of (Reddy et al., 2019), who also reported negative results when running GAIL on images. While improved performance might be possible with more sophisticated adversarial training techniques, we note that this contrasts with our method which uses a fixed reward function obtained through simple supervised learning.
+
+In Appendix D we provide ablation experiments examining the effects of the cost function clipping and the role of the BC loss. We also compare the ensemble approach to a dropout-based approximation and show that DRIL works well in both cases.
+
+# 6.3 CONTINUOUS CONTROL
+
+We next report results of running our method on 6 different continuous control tasks from the PyBullet5 and OpenAI Gym (Brockman et al., 2016) environments. We again used pretrained agents to generate expert demonstrations, and compared to Behavior Cloning and GAIL.
+
+Results for all methods are shown in Figure 4. In these environments we found Behavior Cloning to be a much stronger baseline than for the Atari environments: in several tasks it was able to match expert performance using as little as 3 trajectories, suggesting that covariate shift may be less of an issue. Our method performs similarly to Behavior Cloning on most tasks, except on Walker2D, where it yields improved performance for $N = 1 , 3 , 5$ trajectories. GAIL performs somewhat better than DRIL on HalfCheetah and Walker2D, but performs worse than both DRIL and BC on LunarLander and BipedalWalkerHardcore. The fact that DRIL is competitive across all tasks provides evidence of its robustness.
+
+![](images/b0edd841d3208a643e7aedc62d719e9e8c99705771d310ccf6e981b64bc6aa90.jpg)  
+Figure 3: Results on Atari environments. a) Median final policy performance for different numbers of expert trajectories, taken over 4 seeds (shaded regions are min/max performance) b) Evolution of policy reward and uncertainty cost during training with $N = 3$ trajectories.
+
+# 7 CONCLUSION
+
+Addressing covariate shift has been a long-standing challenge in imitation learning. In this work, we have proposed a new method to address this problem by penalizing the disagreement between an ensemble of different policies trained on the demonstration data. Importantly, our method requires no additional labeling by an expert. Our experimental results demonstrate that DRIL can often match expert performance while using only a small number of trajectories across a wide array of tasks, ranging from tabular MDPs to pixel-based Atari games and continuous control tasks. On the theoretical side, we have shown that our algorithm can provably obtain a low regret bound for problems in which the $\kappa$ parameter is low.
+
+![](images/fc439a33e8fbac82cfd89450bec241d73107c1c8a1ca073b97a8ff5756290cd0.jpg)  
+Figure 4: Results on continuous control tasks.
+
+There are multiple directions for future work. On the theoretical side, characterizing the $\kappa$ parameter on a larger array of problems would help to better understand the settings where our method can expect to do well. Empirically, there are many other settings in structured prediction (Daume´ et al., 2009) where covariate shift is an issue and where our method could be applied. For example, in dialogue and language modeling it is common for generated text to become progressively less coherent as errors push the model off the manifold it was trained on. Our method could potentially be used to fine-tune language or translation models (Cho et al., 2014; Welleck et al., 2019) after training by applying our uncertainty-based cost function to the generated text.
+
+# REFERENCES
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016.
+
+Yuri Burda, Harrison Edwards, Amos Storkey, and Oleg Klimov. Exploration by random network distillation. In International Conference on Learning Representations, 2019. URL https: //openreview.net/forum?id ${ . } = { }$ H1lJJnR5Ym.
+
+Kai-Wei Chang, Akshay Krishnamurthy, Alekh Agarwal, John Langford, and Hal Daume III. Learn- ´ ing to search better than your teacher. 2015.
+
+Ching-An Cheng and Byron Boots. Convergence of value aggregation for imitation learning. arXiv preprint arXiv:1801.07292, 2018.
+
+Kyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, ¨ Holger Schwenk, and Yoshua Bengio. Learning phrase representations using RNN encoder– decoder for statistical machine translation. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 1724–1734, Doha, Qatar, October 2014. Association for Computational Linguistics. doi: 10.3115/v1/D14-1179. URL https://www.aclweb.org/anthology/D14-1179.
+
+Hal Daume, John Langford, and Daniel Marcu. Search-based structured prediction. ´ CoRR, abs/0907.0786, 2009. URL http://arxiv.org/abs/0907.0786.
+
+Mikael Henaff. Explicit explore-exploit algorithms in continuous state spaces. In H. Wallach, H. Larochelle, A. Beygelzimer, F. Alche-Buc, E. Fox, and R. Garnett (eds.), Advances in Neural Information Processing Systems 32, pp. 9377– 9387. Curran Associates, Inc., 2019. URL http://papers.nips.cc/paper/ 9135-explicit-explore-exploit-algorithms-in-continuous-state-spaces. pdf.
+
+Mikael Henaff, Alfredo Canziani, and Yann LeCun. Model-predictive policy learning with uncertainty regularization for driving in dense traffic. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ HygQBn0cYm.
+
+Matteo Hessel, Joseph Modayil, Hado P. van Hasselt, Tom Schaul, Georg Ostrovski, Will Dabney, Dan Horgan, Bilal Piot, Mohammad Gheshlaghi Azar, and David Silver. Rainbow: Combining improvements in deep reinforcement learning. In AAAI, 2018.
+
+Todd Hester, Matej Vecer´ık, Olivier Pietquin, Marc Lanctot, Tom Schaul, Bilal Piot, Dan Horgan, John Quan, Andrew Sendonaris, Ian Osband, Gabriel Dulac-Arnold, John Agapiou, Joel Z. Leibo, and Audrunas Gruslys. Deep q-learning from demonstrations. In 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, pp. 3223–3230, 2018. URL https://www.aaai.org/ocs/index.php/AAAI/ AAAI18/paper/view/16976.
+
+Ashley Hill, Antonin Raffin, Maximilian Ernestus, Adam Gleave, Rene Traore, Prafulla Dhariwal, Christopher Hesse, Oleg Klimov, Alex Nichol, Matthias Plappert, Alec Radford, John Schulman, Szymon Sidor, and Yuhuai Wu. Stable baselines. https://github.com/hill-a/ stable-baselines, 2018.
+
+Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett (eds.), Advances in Neural Information Processing Systems 29, pp. 4565–4573. Curran Associates, Inc., 2016.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization, 2014. URL http://arxiv.org/abs/1412.6980. cite arxiv:1412.6980Comment: Published as a conference paper at the 3rd International Conference for Learning Representations, San Diego, 2015.
+
+Ilya Kostrikov. Pytorch implementations of reinforcement learning algorithms. https:// github.com/ikostrikov/pytorch-a2c-ppo-acktr-gail, 2018.
+
+Hoang M Le, Nan Jiang, Alekh Agarwal, Miroslav Dud´ık, Yisong Yue, and Hal Daume III. Hierar-´ chical imitation and reinforcement learning. arXiv preprint arXiv:1803.00590, 2018.
+
+Timothy P. Lillicrap, Jonathan J. Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. CoRR, abs/1509.02971, 2016.
+
+Yuping Luo, Huazhe Xu, and Tengyu Ma. Learning self-correctable policies and value functions from demonstrations with negative sampling. CoRR, abs/1907.05634, 2019. URL http:// arxiv.org/abs/1907.05634.
+
+Kunal Menda, Katherine Rose Driggs-Campbell, and Mykel J. Kochenderfer. Ensembledagger: A bayesian approach to safe imitation learning. ArXiv, abs/1807.08364, 2018.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, February 2015. ISSN 00280836. URL http://dx.doi.org/10.1038/nature14236.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In Maria Florina Balcan and Kilian Q. Weinberger (eds.), Proceedings of The 33rd International Conference on Machine Learning, volume 48 of Proceedings of Machine Learning Research, pp. 1928–1937, New York, New York, USA, 20–22 Jun 2016. PMLR. URL http: //proceedings.mlr.press/v48/mniha16.html.
+
+Remi Munos and Csaba Szepesv ´ ari. Finite-time bounds for fitted value iteration. ´ J. Mach. Learn. Res., 9:815857, June 2008. ISSN 1532-4435.
+
+Ashvin Nair, Bob McGrew, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Overcoming exploration in reinforcement learning with demonstrations. 2018 IEEE International Conference on Robotics and Automation (ICRA), pp. 6292–6299, 2017.
+
+Ian Osband, Charles Blundell, Alexander Pritzel, and Benjamin Van Roy. Deep exploration via bootstrapped DQN. CoRR, abs/1602.04621, 2016. URL http://arxiv.org/abs/1602. 04621.
+
+Deepak Pathak, Dhiraj Gandhi, and Abhinav Gupta. Self-supervised exploration via disagreement. In ICML, 2019.
+
+Dean A. Pomerleau. Alvinn: An autonomous land vehicle in a neural network. In D. S. Touretzky (ed.), Advances in Neural Information Processing Systems 1, pp. 305–313. Morgan-Kaufmann, 1989. URL http://papers.nips.cc/paper/ 95-alvinn-an-autonomous-land-vehicle-in-a-neural-network.pdf.
+
+Siddharth Reddy, Anca D. Dragan, and Sergey Levine. SQIL: imitation learning via regularized behavioral cloning. CoRR, abs/1905.11108, 2019. URL http://arxiv.org/abs/1905. 11108.
+
+Stephane Ross and Drew Bagnell. Efficient reductions for imitation learning. In Yee Whye Teh and Mike Titterington (eds.), Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, volume 9 of Proceedings of Machine Learning Research, pp. 661–668, Chia Laguna Resort, Sardinia, Italy, 13–15 May 2010. PMLR. URL http://proceedings. mlr.press/v9/ross10a.html.
+
+Stephane Ross and J Andrew Bagnell. Reinforcement and imitation learning via interactive no-regret learning. arXiv preprint arXiv:1406.5979, 2014.
+
+Stephane Ross, Geoffrey Gordon, and Drew Bagnell. A reduction of imitation learning and structured prediction to no-regret online learning. In Geoffrey Gordon, David Dunson, and Miroslav Dudk (eds.), Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics, volume 15 of Proceedings of Machine Learning Research, pp. 627–635, Fort Lauderdale, FL, USA, 11–13 Apr 2011. PMLR. URL http://proceedings.mlr.press/ v15/ross11a.html.
+
+Fumihiro Sasaki, Tetsuya Yohira, and Atsuo Kawaguchi. Sample efficient imitation learning for continuous control. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ BkN5UoAqF7.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. CoRR, abs/1707.06347, 2017. URL http://arxiv.org/abs/ 1707.06347.
+
+Pranav Shyam, Wojciech Jaskowski, and Faustino Gomez. Model-based active exploration. CoRR, abs/1810.12162, 2018.
+
+Nitish Srivastava, Geoffrey E. Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014. URL http://www.cs.toronto.edu/˜rsalakhu/ papers/srivastava14a.pdf.
+
+Wen Sun, Arun Venkatraman, Geoffrey J Gordon, Byron Boots, and J Andrew Bagnell. Deeply aggrevated: Differentiable imitation learning for sequential prediction. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 3309–3318. JMLR. org, 2017.
+
+Arun Venkatraman, Martial Hebert, and J. Andrew Bagnell. Improving multi-step prediction of learned time series models. In Proceedings of the Twenty-Ninth AAAI Conference on Artificial Intelligence, AAAI’15, pp. 3024–3030. AAAI Press, 2015. ISBN 0-262-51129-0. URL http: //dl.acm.org/citation.cfm?id=2888116.2888137.
+
+Ruohan Wang, Carlo Ciliberto, Pierlugi Amadori, and Yiannis Demiris. Random expert distillation: Imitation learning via expert policy support estimation. In Proceedings of International Conference on Machine Learning. ACM, 2019.
+
+Sean Welleck, Kiante Brantley, Hal Daum ´ e III, and Kyunghyun Cho. Non-monotonic sequential text ´ generation. CoRR, abs/1902.02192, 2019. URL http://arxiv.org/abs/1902.02192.
+
+# A PROOFS
+
+Lemma 1. For any $\pi \in \Pi$ we have $J _ { \mathrm { e x p } } ( \pi ) \le \kappa J _ { \mathrm { a l g } } ( \pi )$
+
+Proof. We will first show that for any $\pi \in \Pi$ and $\mathcal { U } \subseteq \mathcal { S }$ , we have $\begin{array} { r } { J _ { \mathrm { e x p } } ( \pi ) \le \frac { \alpha ( \mathcal { U } ) } { \beta ( \mathcal { U } ) } J _ { \mathrm { a l g } } ( \pi ) } \end{array}$ . We can rewrite this as:
+
+$$
+\begin{array} { r l } & { J _ { \mathrm { e x p } } ( \pi ) = \mathbb { E } _ { s \sim d _ { \pi } } \Big [ \| \pi ( \cdot | s ) - \pi ^ { \star } ( \cdot | s ) \| \Big ] } \\ & { \qquad = \mathbb { E } _ { s \sim d _ { \pi } } \Big [ \mathbb { I } ( s \in \mathcal { U } ) \| \pi ( \cdot | s ) - \pi ^ { \star } ( \cdot | s ) \| \Big ] + \mathbb { E } _ { s \sim d _ { \pi } } \Big [ \mathbb { I } ( s \notin \mathcal { U } ) \| \pi ( \cdot | s ) - \pi ^ { \star } ( \cdot | s ) \| \Big ] } \end{array}
+$$
+
+We begin by bounding the first term:
+
+$$
+\begin{array} { r l } { \mathbb { E } _ { s \sim \theta _ { 0 } } \bigg [ \big ( | s - z | \big ) \| \pi \langle | s \rangle - \pi ^ { * } ( | s ) \big \| \bigg ] = \displaystyle \sum _ { s \in \theta _ { 0 } } d _ { \pi } ( s ) \| \pi \langle | s \rangle - \pi ^ { * } ( | s ) \| } \\ & { \quad = \displaystyle \sum _ { s \in \theta _ { 0 } } \frac { \lambda _ { \pi } ( s ) } { d \pi ^ { s } ( s ) } d _ { \pi ^ { s } ( s ) } \| x ( s ) - \pi ^ { * } ( | s | ) \| } \\ & { \quad \le \displaystyle \sum _ { s \in \theta _ { 0 } } \bigg ( \frac { \eta _ { 0 } \kappa \kappa \kappa \| s \| } { \pi \langle s | \theta _ { 0 } \rangle ( \pi ^ { s } ( s ) \rangle } \bigg ) d _ { \pi ^ { s } ( s ) } \langle s | \pi | ( s ) \rangle - \pi ^ { * } ( | s | ) \bigg \| } \\ & { \quad \quad \sim \epsilon ( | L \eta \langle \frac { \eta _ { 0 } \kappa \kappa \| } { \pi \langle s | \theta _ { 0 } \rangle ( \pi ^ { s } ( s ) \rangle } \Big ) d _ { \pi ^ { s } ( s ) } \bigg \| \pi ( s | \delta ) \| \pi ( s ) - \pi ^ { * } ( | s | ) \| } \\ & { \quad \quad = \epsilon ( | L \eta \sum _ { s \in \theta _ { 0 } } d _ { \pi ^ { s } ( s ) } \langle \theta | \pi ( s ) \rangle - \pi ^ { * } ( | s | ) \| } \\ & { \quad \le \alpha ( | L \eta \langle \frac { \eta _ { 0 } \kappa \| } { \pi \langle s | \theta _ { 0 } \rangle ( \pi ^ { s } ( s ) \rangle } \| x ( s ) - x ^ { * } ( | s ) \| } \\ & { \quad \quad = \epsilon ( | L \eta \langle \frac { \eta _ { 0 } \kappa \kappa \| } { \pi \langle s | \theta _ { 0 } \rangle ( \pi ^ { s } ( s ) \rangle } \| x ( s ) - x ^ { * } ( | s ) \| } \\ & { \quad = \epsilon ( | L \eta \langle \frac { \eta _ { 0 } \kappa \| } { \pi \langle s | \theta _ { 0 } \rangle ( \pi ^ { s } ( s ) \rangle } \| x ( s ) - x ^ { * } ( | s ) \| } \\ & { \quad = \epsilon ( | L \eta \langle \frac { \eta _ { 0 } \kappa \| } { \pi \langle s | \theta _ { 0 } \rangle } \| x ( s ) - x ^ { * } ( | s ) \| } \\ & \end{array}
+$$
+
+We next bound the second term:
+
+$$
+\begin{array} { r l } { \mathbb { E } _ { s \sim d _ { \pi } } \Big [ \mathbb { I } ( s \notin \mathcal { U } ) \| \pi ( \cdot | s ) - \pi ^ { \star } ( \cdot | s ) \| \Big ] \leq \mathbb { E } _ { s \sim d _ { \pi } } \Big [ \mathbb { I } ( s \notin \mathcal { U } ) \Big ] } & { } \\ & { \leq \mathbb { E } _ { s \sim d _ { \pi } } \Big [ \mathbb { I } ( s \notin \mathcal { U } ) \frac { \operatorname* { m i n } _ { a \in A } \operatorname { V a r } _ { \pi _ { i } \sim \Pi _ { \mathrm { E } } } \big [ \pi _ { i } ( a | s ) \big ] } { \beta ( \mathcal { U } ) } \Big ] } \\ & { = \displaystyle \frac { 1 } { \beta ( \mathcal { U } ) } \mathbb { E } _ { s \sim d _ { \pi } } \Big [ \mathbb { I } ( s \notin \mathcal { U } ) \sum _ { a \in A } \pi ( a | s ) \operatorname { V a r } _ { \pi _ { i } \sim \Pi _ { \mathrm { E } } } \big [ \pi _ { i } ( a | s ) \big ] \Big ] } \\ & { = \displaystyle \frac { 1 } { \beta ( \mathcal { U } ) } \sum _ { s \notin \mathcal { U } } d _ { \pi } ( s ) \sum _ { a \in \mathcal { A } } \pi ( a | s ) \operatorname { V a r } _ { \pi _ { i } \sim \Pi _ { \mathrm { E } } } \big [ \pi _ { i } ( a | s ) \big ] } \end{array}
+$$
+
+Now observe we can decompose the RL cost as follows:
+
+$$
+\begin{array} { r l } & { J _ { \mathrm { U } } ( \boldsymbol { \pi } ) = \mathbb { E } _ { s \sim d _ { \boldsymbol { \pi } } , a \sim \boldsymbol { \pi } ( \cdot \vert s ) } \left[ \mathrm { V a r } _ { \boldsymbol { \pi } _ { i } \sim \Pi _ { \mathrm { E } } } \pi _ { i } ( a \vert s ) \right] } \\ & { \qquad = \displaystyle \sum _ { s } d _ { \boldsymbol { \pi } } ( s ) \sum _ { a } \pi ( a \vert s ) \left[ \mathrm { V a r } _ { \boldsymbol { \pi } _ { i } \sim \Pi _ { \mathrm { E } } } \pi _ { i } ( a \vert s ) \right] } \\ & { \qquad = \displaystyle \sum _ { s \in U } d _ { \boldsymbol { \pi } } ( s ) \sum _ { a } \pi ( a \vert s ) \left[ \mathrm { V a r } _ { \boldsymbol { \pi } _ { i } \sim \Pi _ { \mathrm { E } } } \pi _ { i } ( a \vert s ) \right] } \\ & { \qquad = \underbrace { \sum _ { s \in U } d _ { \boldsymbol { \pi } } ( s ) \sum _ { a } \pi ( a \vert s \vert ) \left[ \mathrm { V a r } _ { \boldsymbol { \pi } _ { i } \sim \Pi _ { \mathrm { E } } } \pi _ { i } ( a \vert s ) \right] } _ { B ( \boldsymbol { \pi } ) } + \underbrace { \sum _ { s \neq l } d _ { \boldsymbol { \pi } } ( s ) \sum _ { a } \pi ( a \vert s ) \left[ \mathrm { V a r } _ { \boldsymbol { \pi } _ { i } \sim \Pi _ { \mathrm { E } } } \pi _ { i } ( a \vert s ) \right] } _ { A ( \boldsymbol { \pi } ) } } \end{array}
+$$
+
+Putting these together, we get the following:
+
+$$
+\begin{array} { r l } { J _ { \mathrm { c s p } } ( \pi ) \le \alpha ( \mathcal { U } ) J _ { \mathrm { R C } } ( \pi ) + \displaystyle \frac { 1 } { \beta ( \mathcal { U } ) } A ( \pi ) } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \alpha ( \mathcal { U } ) \beta ( \mathcal { U } ) } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \alpha ( \mathcal { U } ) } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ &  \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad  \end{array}
+$$
+
+Here we have used the fact that β(U ) ≤ 1 since 0 ≤ π(a|s) ≤ 1 and α(U ) ≥ sups∈U d?π(s)d?π(s) hence $\begin{array} { r } { \frac { 1 } { \alpha ( \mathcal { U } ) } \le 1 } \end{array}$ . Taking the minimum over subsets $\mathcal { U } \subseteq \mathcal { S }$ , we get $J _ { \mathrm { e x p } } ( \pi ) \le \kappa J _ { \mathrm { a l g } } ( \pi )$ .
+
+Lemma 2. $\begin{array} { r } { \operatorname* { m i n } _ { \pi \in \Pi } J _ { \mathrm { a l g } } ( \pi ) \le 2 \epsilon } \end{array}$
+
+Proof. Plugging the optimal policy into $J _ { \mathrm { a l g } }$ , we get:
+
+$$
+\begin{array} { r l } { J _ { \mathrm { B E } } ( \pi ^ { * } ) = J _ { \mathrm { B C } } ( \pi ^ { * } ) + J _ { \mathrm { U } } ( \pi ^ { * } ) } \\ & { \qquad = 0 + \mathbb { E } _ { s \sim \mathcal { A } _ { s } , \pi \sim \pi ^ { * } ( \cdot ) s } \Big [ \mathrm { V a r } _ { \pi _ { s } \sim \Pi _ { \pi } } \big [ \pi _ { s } ( a | s ) \big ] \Big ] } \\ & { \qquad = \mathbb { E } _ { s \sim d _ { \pi ^ { * } } , a \sim \pi ^ { * } ( \cdot ) s } \Big [ \displaystyle \frac { 1 } { E } \sum _ { i = 1 } ^ { E } \Big ( \pi _ { s } ( a | s ) - \pi _ { i } ( a | s ) \Big ) ^ { 2 } \Big ] } \\ & { \qquad \le \mathbb { E } _ { s \sim d _ { \pi ^ { * } } , a \sim \pi ^ { * } ( \cdot ) s } \Big [ \displaystyle \frac { 1 } { E } \sum _ { i = 1 } ^ { E } \Big ( \pi _ { i } ( a | s ) - \pi ^ { * } ( a | s ) \Big ) ^ { 2 } + \Big ( \pi ( a | s ) - \pi ^ { * } ( a | s ) \Big ) ^ { 2 } \Big ] } \\ & { \qquad = \underbrace { \mathbb { E } _ { s \sim d _ { \pi ^ { * } } , a \sim \pi ^ { * } ( \cdot ) s } } _ { \texttt { D e r m i l } } \Big [ \displaystyle \frac { 1 } { E } \sum _ { i = 1 } ^ { E } \Big ( \pi _ { i } ( a | s ) - \pi ^ { * } ( a | s ) \Big ) ^ { 2 } \Big ] + \underbrace { \mathbb { E } _ { s \sim d _ { \pi ^ { * } } , a \sim \pi ^ { * } ( \cdot ) s } } _ { \texttt { T e m m 2 } } \Big ( \Big | \Big ( \pi ( a | s ) - \pi ^ { * } ( a | s ) \Big ) \Big ) } \end{array}
+$$
+
+We will first bound Term 1:
+
+$$
+\begin{array} { r l } { \displaystyle \sum _ { k \to \alpha < \alpha , \nu \to \nu + \nu + 1 ; \nu } [ \displaystyle \frac { 1 } { E } \sum _ { i = 1 } ^ { E } ( \pi _ { i } ( \alpha | \boldsymbol s ) - \pi ^ { * } ( \alpha | \boldsymbol s ) ) ^ { 2 } ] = \frac { 1 } { E } \mathbb { E } _ { \alpha \to \alpha , \nu } \Bigg [ \sum _ { \alpha \in A } \boldsymbol s ^ { \star } ( \alpha | \boldsymbol s ) \sum _ { \nu = 1 } ^ { E } \Bigg ( \alpha _ { 1 } ( \alpha | \boldsymbol s ) - \pi ^ { * } ( \alpha | \boldsymbol s ) \Bigg ) ^ { 2 } } & { } \\ & { \leq \frac { 1 } { E } \mathbb { E } _ { \alpha \to \alpha , \nu } \Bigg [ \sum _ { \alpha \in A } \boldsymbol s \Bigg ( \alpha | \boldsymbol s \rangle \sum _ { \nu = 1 } ^ { E } \Big | \alpha ( \boldsymbol s | \boldsymbol s ) - \pi ^ { * } ( \alpha | \boldsymbol s ) \Big | \Bigg ] } \\ & { \leq \frac { 1 } { E } \mathbb { E } _ { \alpha \to \alpha , \nu } \Bigg [ \displaystyle \sum _ { \alpha \in B \times \alpha } \Bigg [ \sum _ { \alpha \in A \times \alpha } \Bigg ] ^ { E } \pi _ { i } ( \alpha | \boldsymbol s ) - \pi ^ { * } ( \alpha | \boldsymbol s ) \Bigg ] \Bigg ] } \\ & { \leq \frac { 1 } { E } \frac { E } { E } \sum _ { \alpha \to \alpha , \nu \to \nu + 1 } \Bigg [ \displaystyle \frac { 1 } { E } \sum _ { \alpha \in B \times \alpha } \Bigg [ | \boldsymbol s | \boldsymbol s \rangle - \pi ^ { * } ( \alpha | \boldsymbol s ) \Big | \Bigg ] } \\ & { \leq \frac { 1 } { E } \displaystyle \sum _ { \alpha \to \alpha , \nu \to \nu + 1 } ^ { E } [ | \overline { { \alpha } } _ { 1 } ( \boldsymbol s | \boldsymbol s ) - \pi ^ { * } ( | \boldsymbol s | \boldsymbol s | ] ] } \\ & { \leq \frac { 1 } { E } \displaystyle \sum _ { \alpha \to \alpha } ^ { E } \exp ( \sum _ { \alpha \in B \times \alpha } \Bigg [ \exp ( \alpha | \boldsymbol s | \boldsymbol s | \boldsymbol s | \boldsymbol s | \boldsymbol s | \boldsymbol s | \boldsymbol s | \boldsymbol s ) - \pi ^ { * } ( | \boldsymbol s | \boldsymbol s | \boldsymbol s | \boldsymbol s | \boldsymbol s ) | \Bigg ] } \\ & { \leq \frac { 1 } { E } \displaystyle \sum _ { \alpha \to \infty } ^ { E } \mathrm { e } } \\ & { = \varepsilon } \end{array}
+$$
+
+We will next bound Term 2:
+
+$$
+\begin{array} { r l } { \exp _ { \tau } \left( \tau \mathrm { d } \boldsymbol { \theta } \right) } &  \leq \exp _ { \tau } \left( \tau \mathrm { d } \boldsymbol { \theta } \right) , \quad \forall \mathrm { d } \boldsymbol { \theta } \right) \} \left\{ \sum _ { j = 1 , \ldots , N - 1 } ^ { N } \exp _ { \tau } \left( \mathrm { d } \boldsymbol { \theta } \right) , \quad \sum _ { k = 0 } ^ { N } \exp _ { \tau } \left( \mathrm { d } \boldsymbol { \theta } \right) \right\} ^ { \frac { 1 } { N } } \\ & { = \sum _ { k = 0 } ^ { N } \exp _ { \tau } \left( \mathrm { d } \boldsymbol { \theta } \right) , \quad \sum _ { k = 0 } ^ { N } \exp _ { \tau } \left( \mathrm { d } \boldsymbol { \theta } \right) , \quad k = \frac { N } { N } \sum _ { k = 0 } ^ { N } \exp _ { \tau } \left( \mathrm { d } \boldsymbol { \theta } \right) , } \\ & { = \sum _ { k = 0 } ^ { N } \exp _ { \tau } \exp _ { \tau } \sum _ { k = 0 } ^ { N } \exp _ { \tau } \left( \mathrm { d } \boldsymbol { \theta } \right) , \quad k = \frac { N } { N } \sum _ { k = 0 } ^ { N } \exp _ { \tau } \left( \mathrm { d } \boldsymbol { \theta } \right) , } \\ & { = \sum _ { k = 0 } ^ { N } \exp _ { \tau } \sum _ { k = 0 } ^ { N } \exp _ { \tau } \sum _ { k = 0 } ^ { N } \exp _ { \tau } \left( \mathrm { d } \boldsymbol { \theta } \right) , } \\ & { \leq \sum _ { k = 0 } ^ { N } \exp _ { \tau } \exp _ { \tau } \sum _ { k = 0 } ^ { N } \exp _ { \tau } \sum _ { k = 0 } ^ { N } \exp _ { \tau } \left( \mathrm { d } \boldsymbol { \theta } \right) , } \\ & { = \sum _ { k = 0 } ^ { N } \sum _ { k = 0 } ^ { N } \exp _ { \tau } \left( \mathrm { d } \boldsymbol { \theta } \right) , \quad \mathrm { ~ a ~ n ~ d ~ } \mathrm { ~ N ~ o ~ s i g h ~ } \mathrm { ~ } } \\ & { = \sum _ { k = 0 } ^ { N } \exp _ { \tau } \left( \mathrm { d } \boldsymbol { \theta } \right) , \quad \mathrm { ~ a ~ n ~ d ~ } \mathrm { ~ N ~ o ~ s i g h ~ } \mathrm { ~ H ~ } } \\ &  \leq \frac { 1 } { N } \sum _ { k = 0 } ^ { N } \exp _ { \tau } \left( \mathrm { d } \boldsymbol  \ \end{array}
+$$
+
+The last step follows from our optimization oracle assumption: $\begin{array} { r } { 0 \leq \operatorname* { m i n } _ { \pi \in \Pi } J _ { \mathrm { B C } } ( \pi ) \leq J _ { \mathrm { B C } } ( \pi ^ { \star } ) = } \end{array}$ 0, hence $J _ { \mathrm { B C } } ( \pi _ { i } ) \le 0 + \epsilon = \epsilon$ . Combining the bounds on the two terms, we get $J _ { \mathrm { a l g } } ( \pi ^ { \star } ) \leq 2 \epsilon$ . Since $\pi ^ { \star } \in \Pi$ , the result follows.
+
+Theorem 1. Let $\hat { \pi }$ be the result of minimizing $J _ { \mathrm { a l g } }$ using our optimization oracle, and assume that $Q _ { T - t + 1 } ^ { \pi ^ { \star } } ( s , a ) - Q _ { T - t + 1 } ^ { \pi ^ { \star } } ( s , \pi ^ { \star } ) \leq u$ for all $a \in \mathcal { A } , t \in \{ 1 , 2 , . . . , T \} , d _ { \pi } ^ { t } ( s ) > 0 ,$ . Then $\hat { \pi }$ satisfies $J ( \hat { \pi } ) \le J ( \pi ^ { \star } ) + 3 u \kappa \epsilon T$ .
+
+Proof. By our optimization oracle and Lemma 2, we have
+
+$$
+\begin{array} { r l } & { J _ { \mathrm { a l g } } ( \hat { \pi } ) \leq \displaystyle \operatorname* { m i n } _ { \pi \in \Pi } J _ { \mathrm { a l g } } ( \pi ) + \epsilon } \\ & { \qquad \leq 2 \epsilon + \epsilon } \\ & { \qquad = 3 \epsilon } \end{array}
+$$
+
+Combining with Lemma 1, we get:
+
+$$
+\begin{array} { l } { { J _ { \mathrm { e x p } } ( \hat { \pi } ) \leq \kappa J _ { \mathrm { a l g } } ( \hat { \pi } ) } } \\ { { \leq 3 \kappa \epsilon } } \end{array}
+$$
+
+Applying Theorem 1 from (Ross et al., 2011), we get $J ( \hat { \pi } ) \le J ( \pi ^ { \star } ) + 3 u \kappa \epsilon T$ .
+
+# B IMPORTANCE OF BEHAVIOR CLONING COST
+
+The following example shows how minimizing the uncertainty cost alone without the BC cost can lead to highly sub-optimal policies if the demonstration data is generated by a stochastic policy which is only slightly suboptimal. Consider the following deterministic chain MDP:
+
+$$
+a _ { 0 } \underbrace  \sum _ { \left( { \begin{array} { l } { s _ { 0 } } \end{array} } \right) } ^ { a _ { 1 } } { \overbrace { \left( s _ { 1 } \right) } ^ { a _ { 1 } } } _ { a _ { 0 } } ^ { a _ { 1 } } { \overbrace { \left( s _ { 2 } \right) } ^ { a _ { 1 } } } _ { a _ { 0 } } ^ { a _ { 1 } } { \overbrace { \left( s _ { 2 } \right) } ^ { a _ { 1 } } { \overbrace { \left( s _ { 3 } \right) } ^ { a _ { 2 } } } ^ { a _ { 1 } } } _ { a _ { 0 } } ^ { a _ { 1 } }
+$$
+
+The agent always starts in $s _ { 1 }$ , and gets a reward of 1 in $s _ { 3 }$ and 0 elsewhere. The optimal policy is given by:
+
+$$
+\begin{array} { r } { \pi ^ { \star } ( \cdot | s _ { 0 } ) = ( 0 , 1 ) } \\ { \pi ^ { \star } ( \cdot | s _ { 1 } ) = ( 0 , 1 ) } \\ { \pi ^ { \star } ( \cdot | s _ { 2 } ) = ( 0 , 1 ) } \\ { \pi ^ { \star } ( \cdot | s _ { 3 } ) = ( 0 , 1 ) } \end{array}
+$$
+
+Assume the demonstration data is generated by the following policy, which is only slightly suboptimal:
+
+$$
+\begin{array} { r l } & { \pi _ { \mathrm { d e m o } } ( \cdot | s _ { 0 } ) = ( 0 , 1 ) } \\ & { \pi _ { \mathrm { d e m o } } ( \cdot | s _ { 1 } ) = ( 0 , 1 ) } \\ & { \pi _ { \mathrm { d e m o } } ( \cdot | s _ { 2 } ) = ( 0 . 1 , 0 . 9 ) } \\ & { \pi _ { \mathrm { d e m o } } ( \cdot | s _ { 3 } ) = ( 0 , 1 ) } \end{array}
+$$
+
+Let us assume realizability and perfect optimization for simplicity. If both transitions $( s _ { 2 } , a _ { 0 } )$ and $( s _ { 2 } , a _ { 1 } )$ appear in the demonstration data, then Random Expert Distillation (RED) will assign zero cost to both transitions. If we do not use bootstrapped samples to train the ensemble, then DRIL without the BC cost (we will call this UO-DRIL for Uncertainty-Only DRIL) will also assign zero cost to both transitions since all models in the ensemble would recover the Bayes optimal solution given the demonstration data. If we are using bootstrapped samples, then the Bayes optimal solution for each bootstrapped sample may differ and thus the different policies in the ensemble might disagree in their predictions, although given enough demonstration data we would expect these differences (and thus the uncertainty cost) to be small.
+
+Note also that since no samples at the state $s _ { 0 }$ occur in the demonstration data, both RED and UODRIL will likely assign high uncertainty costs to state-action pairs at $( s _ { 0 } , a _ { 0 } ) , ( s _ { 0 } , a _ { 1 } )$ and thus avoid highly suboptimal policies which get stuck at $s _ { 0 }$ .
+
+Now consider policies $\hat { \pi } _ { 1 } , \hat { \pi } _ { 2 }$ given by:
+
+$$
+\begin{array} { r } { \hat { \pi } _ { 1 } ( \cdot | s _ { 0 } ) = ( 0 , 1 ) } \\ { \hat { \pi } _ { 1 } ( \cdot | s _ { 1 } ) = ( 0 , 1 ) } \\ { \hat { \pi } _ { 1 } ( \cdot | s _ { 2 } ) = ( 1 , 0 ) } \\ { \hat { \pi } _ { 1 } ( \cdot | s _ { 3 } ) = ( 0 , 1 ) } \end{array}
+$$
+
+and
+
+$$
+\begin{array} { r l } & { \hat { \pi } _ { 2 } ( \cdot | s _ { 0 } ) = ( 0 , 1 ) } \\ & { \hat { \pi } _ { 2 } ( \cdot | s _ { 1 } ) = ( 0 , 1 ) } \\ & { \hat { \pi } _ { 2 } ( \cdot | s _ { 2 } ) = ( 0 . 2 , 0 . 8 ) } \\ & { \hat { \pi } _ { 2 } ( \cdot | s _ { 3 } ) = ( 0 , 1 ) } \end{array}
+$$
+
+Both of these policies only visit state-action pairs which are visited by the demonstration policy. In the case described above, both RED and UO-DRIL will assign $\hat { \pi } _ { 1 }$ and $\hat { \boldsymbol { \pi } } _ { 2 }$ similarly low costs. However, $\hat { \pi } _ { 1 }$ will cycle forever between $s _ { 1 }$ and $s _ { 2 }$ , never collecting reward, while $\hat { \boldsymbol { \pi } } _ { 2 }$ will with high probability reach $s _ { 3 }$ and stay there, thus achieving high reward. This shows that minimizing the uncertainty cost alone does not necessarily distinguish between good and bad policies. However, $\hat { \pi } _ { 1 }$ will incur a higher BC cost than $\hat { \boldsymbol { \pi } } _ { 2 }$ , since $\hat { \boldsymbol { \pi } } _ { 2 }$ more closely matches the demonstration data at $s _ { 2 }$ . This shows that including the BC cost can be important for further disambiguating between policies which all stay within the distribution of the demonstration data, but have different behavior within that distribution.
+
+# C EXPERIMENTAL DETAILS
+
+# C.1 ATARI ENVIRONMENTS
+
+All behavior cloning models were trained to minimize the negative log-likelihood classification loss on the demonstration data for 500 epochs using Adam (Kingma & Ba, 2014) and a learning rate of $2 . 5 \cdot 1 0 ^ { - 4 }$ . We stopped training once the validation error did not improve for 20 epochs. For our method, we initially performed a hyperparameter search on Space Invaders over the values shown in Table 1
+
+Table 1: Hyperparameters for DRIL   
+
+<table><tr><td>Hyperparameter</td><td>Values Considered</td><td>Final Value</td></tr><tr><td>Policy Learning rate</td><td>2.5:10-2,2.5:10 -3,2.5:10-4</td><td>2.5:10-3</td></tr><tr><td>Quantile cutoff</td><td>0.8, 0.9, 0.95, 0.98</td><td>0.98</td></tr><tr><td>Number of supervised updates</td><td>1,5</td><td>1</td></tr><tr><td>Number of policies in ensemble</td><td>5</td><td>5</td></tr><tr><td>Gradient clipping</td><td>0.1</td><td>0.1</td></tr><tr><td>Entropy coefficient</td><td>0.01</td><td>0.01</td></tr><tr><td>Value loss coeffcient</td><td>0.5</td><td>0.5</td></tr><tr><td>Number of steps</td><td>128</td><td>128</td></tr><tr><td>Parallel Environments</td><td>16</td><td>16</td></tr></table>
+
+We then chose the best values and kept those hyperparameters fixed for all other environments. All other A2C hyperparameters follow the default values in the repo (Kostrikov, 2018): policy networks consisted of 3-layer convolutional networks with $8 - 3 2 - 6 4 $ feature maps followed by a single-layer MLP with 512 hidden units.
+
+For GAIL, we used the implementation in (Kostrikov, 2018) and replaced the MLP discriminator by a CNN discriminator with the same architecture as the policy network. We initially performed a hyperparameter search on Breakout with 10 demonstrations over the values shown in Table 2. However, we did not find any hyperparameter configuration which performed better than behavioral cloning.
+
+Table 2: Hyperparameters for GAIL   
+
+<table><tr><td>Hyperparameter</td><td>Values Considered</td><td>Final Value</td></tr><tr><td>Policy Learning rate</td><td>2.5· 10-2,2.5· 10-3,2.5·10-4</td><td>2.5:10-3</td></tr><tr><td>Discriminator Learning rate</td><td>2.5 : 10-2,2.5 : 10-3,2.5· 10-4</td><td>2.5 : 10-3</td></tr><tr><td>Number of discriminator updates</td><td>1,5,10</td><td>5</td></tr><tr><td>Gradient clipping</td><td>0.1</td><td>0.1</td></tr><tr><td>Entropy coefficient</td><td>0.01</td><td>0.01</td></tr><tr><td>Value loss coefficient</td><td>0.5</td><td>0.5</td></tr><tr><td>Number of steps</td><td>128</td><td>128</td></tr><tr><td>Parallel Environments</td><td>16</td><td>16</td></tr></table>
+
+# C.2 CONTINUOUS CONTROL
+
+All behavior cloning and ensemble models were trained to minimize the mean-squared error regression loss on the demonstration data for 500 epochs using Adam (Kingma & Ba, 2014) and a learning rate of $2 . 5 \cdot 1 0 ^ { - 4 }$ . Policy networks were 2-layer fully-connected MLPs with tanh activations and 64 hidden units.
+
+Table 3: Hyperparameters (our method)   
+
+<table><tr><td>Hyperparameter</td><td>Values Considered</td><td>Final Value</td></tr><tr><td>Policy Learning rate</td><td>2.5·10-3,2.5.10-4,1·10-4,5:10-5</td><td>2.5:10-5</td></tr><tr><td>Quantile cutoff</td><td>0.98</td><td>0.98</td></tr><tr><td>Number of supervised updates</td><td>1</td><td>1</td></tr><tr><td>Number of policies in ensemble</td><td>5</td><td>5</td></tr><tr><td>Gradient clipping</td><td>0.1</td><td>0.1</td></tr><tr><td>Entropy coefficient</td><td>0.01</td><td>0.01</td></tr><tr><td>Value loss coefficient</td><td>0.5</td><td>0.5</td></tr><tr><td>Number of steps</td><td>128</td><td>128</td></tr><tr><td>Parallel Environments</td><td>16</td><td>16</td></tr></table>
+
+# D ABLATION EXPERIMENTS
+
+In this section we provide ablation experiments examining the effects of the cost function clipping and the role of the BC loss. We also compare the ensemble approach to a dropout-based approximation and show that DRIL works well in both cases.
+
+Table 4: Ablation Experiments with 3 expert trajectories   
+
+<table><tr><td>Environment</td><td>SpaceInvaders</td><td>Breakout</td><td>BeamRider</td></tr><tr><td>DRIL (ensemble)</td><td>555.7</td><td>286.7</td><td>2033.4</td></tr><tr><td>DRIL (dropout)</td><td>581.4</td><td>205.4</td><td>2124.5</td></tr><tr><td>DRIL (raw cost)</td><td>421.8</td><td>70.9</td><td>1265.5</td></tr><tr><td>DRIL (no BC cost)</td><td>102.1</td><td>78.3</td><td>538.4</td></tr><tr><td>BC</td><td>257.0</td><td>2.7</td><td>689.7</td></tr></table>
+
+Results are shown in Figure 4. First, switching from the clipped cost in $\{ - 1 , + 1 \}$ to the the raw cost causes a drop in performance. One explanation may be that since the raw costs are always positive (which corresponds to a reward which is always negative), the agent may learn to terminate the episode early in order to minimize the total cost incurred. Using a cost/reward which has both positive and negative values avoids this behavior.
+
+Second, optimizing the pure BC cost performs better than the pure uncertainty cost for some environments (SpaceInvaders, BeamRider) while optimizing the pure uncertainty cost performs better than BC in Breakout. DRIL, which optimizes both, has robust performance and performs the best over all environments.
+
+For the dropout approximation we trained a single policy network with a dropout rate of 0.1 applied to all layers except the last, and estimated the variance for each state-action pair using 5 different dropout masks. Similarly to the ensemble approach, we computed the $9 8 ^ { \mathrm { t h } }$ quantile of the variance on the demonstration data and used this value in our clipped cost. MC-dropout performs similarly to the ensembling approach, which shows that our method can be paired with different approaches to posterior estimation.

parse/train/zOngaSKrElL/zOngaSKrElL.md

@@ -0,0 +1,258 @@
+# Self-Supervised Bug Detection and Repair
+
+Miltiadis Allamanis, Henry Jackson-Flux∗, Marc Brockschmidt Microsoft Research, Cambridge, UK {miallama, mabrocks}@microsoft.com
+
+# Abstract
+
+Machine learning-based program analyses have recently shown the promise of integrating formal and probabilistic reasoning towards aiding software development. However, in the absence of large annotated corpora, training these analyses is challenging. Towards addressing this, we present BUGLAB, an approach for selfsupervised learning of bug detection and repair. BUGLAB co-trains two models: (1) a detector model that learns to detect and repair bugs in code, (2) a selector model that learns to create buggy code for the detector to use as training data. A Python implementation of BUGLAB improves by up to $30 \%$ upon baseline methods on a test dataset of 2374 real-life bugs and finds 19 previously unknown bugs in open-source software.
+
+# 1 Introduction
+
+Detecting and repairing bugs in source code requires strong reasoning skills over formal structures (e.g. data and control flow) and ambiguous information (e.g. identifier names, coding idioms, and comments). Traditional program analyses are able to detect critical bugs through formal reasoning and combinatorial search, but need to be manually coded by experts. That is a lengthy and costly process, which misses the opportunity to use ambiguous information pervasive within code.
+
+Towards broadening the applicability of such methods, and utilizing ambiguous information, deep learning-based bug detection methods are being investigated [22, 3, 13]. These methods have the potential to further improve the engineering of software we rely on every day. However, many challenges in the area remain open, such as creating robust bug detection and repair methods that cover a wide range of common bugs in the absence of large supervised training corpora. Existing work focuses on randomly inserted bugs [22, 13], Cloze test proxy tasks [3], corpora of small code edits that may contain bugs [9] or build errors [28]. All these approaches rely on datasets of very limited size or ones known not to be representative of the characteristics of bugs found in real code.
+
+In this work, we propose BUGLAB, a self-supervised approach that trains robust bug detectors by co-training a bug selector that learns to create hard-to-detect bugs (Sec. 2). For example, for a given code snippet with two well-named variables, a variable misuse bug may be easy to detect and repair, whereas an incorrect comparison operator might be significantly harder to identify. We propose a neural architecture for BUGLAB (Sec. 3) and implement it for Python (Sec. 4). Our implementation considers four broad classes of seemingly simple, yet hard-to-detect bugs and shows improved performance over training with randomly-inserted bugs on PYPIBUGS, a new, manually curated test set of 2374 real-life bugs (Sec. 5). Furthermore, we tested our trained models on popular open-source Python packages and identified 19 previously unreported bugs, though false positive rates of $\sim 9 8 \%$ remain impractical. We hope that creating machine learning methods that can detect these bugs early and assist developers will speed up software development and allow engineers to deliver more robust software. We release PyPIBugs and our code at https://github.com/ microsoft/neurips21-self-supervised-bug-detection-and-repair.
+
+# 2 Self-Supervised Bug Detection
+
+In this section, we first introduce the concept of code rewriting, and then use it to define BUGLAB as a framework for self-supervised learning of bug detection and repair.
+
+Code Rewriting Rewriting is common within compilers and their optimizations, test-driven searchbased bug repair tools, mutation testing, and refactoring tools. Rewrites can be semantics-preserving (e.g. renamings of local variables), or semantics-altering (e.g. replacing $> = \log ~ ! = )$ .
+
+Let $s$ denote the set of all syntax trees (not necessarily rooted in the start symbol of the language grammar). Syntax tree locations $\ell \in \{ \epsilon \} \cup \mathbb { N } ^ { * }$ in a syntax tree $\mathrm { s } \in { \mathcal { S } }$ are recursively defined, where $\mathrm { s } _ { \vert \epsilon } = \mathrm { s }$ and $\mathrm { s } _ { | \ell }$ for $\ell = \ell ^ { \prime } \circ i$ is the $i$ -th child of $\mathrm { s } _ { \vert \ell ^ { \prime } }$ (i.e. s|(2,3) denotes the third child of the second child of s). We define a rewrite rule $\rho = ( \mathrm { m } _ { \rho } , \mathrm { t } _ { \rho } )$ as a pair of a matching function $\operatorname { m } _ { \rho } : S  \{ t r u e , f a l s e \}$ and a transformation function $\mathrm { t } _ { \rho } : { \mathcal { S } }  { \mathcal { S } }$ . The matching function $\mathrm { m } _ { \rho } ( \mathrm { s } )$ yields true iff the rule $\rho$ is applicable at the root of a subtree s. The transformation function can be applied to obtain a transformed syntax tree. For convenience, we define $\mathrm { t } _ { \rho } ( \mathrm { s } ) = \mathrm { s }$ iff $\mathrm { m } _ { \rho } ( \mathrm { s } ) = f a l s e$ . We then write $\rho ( \mathrm { s } )$ to indicate the modification of a syntax tree s using $\rho$ when possible, and otherwise the identity function. For reversible rewrite rules $\rho$ , we denote the inverse rule as $\rho ^ { - 1 }$ such that $\rho ^ { - 1 } ( \rho ( \mathrm { s } ) ) = \mathbf { \dot { s } }$ holds. We discuss concrete rewrite rules $\rho$ in Sec. 4.
+
+Given a set of rewrite rules $\mathcal { R }$ we define the set of “potential rewrites” in a syntax tree s as $R _ { \mathrm { s } } ^ { \mathcal { R } } =$ $\{ \langle \ell , \rho \rangle \mid \rho \in { \mathcal { R } } , \ell$ location in s, $, \mathbf { m } _ { \rho } ( \mathbf { s } _ { | \ell } ) = t r u e \}$ . For each tuple $\langle \ell , \rho \rangle \in R _ { \mathrm { s } } ^ { \mathcal { R } }$ , we use $\mathrm { s } ^ { \prime } = \mathrm { s } [ \rho ] \varrho$ to denote the new syntax tree obtained by applying $\rho$ at location $\ell$ of s. In BUGLAB, we train models that use rewrites from $R _ { \mathrm { s } } ^ { \mathcal { R } }$ to insert and repair bugs. We will discuss such neural models in Sec. 3.
+
+BUGLAB In BUGLAB, we are interested in selfsupervised training of a robust bug detector model $D _ { \theta }$ with parameters $\theta$ on an unannotated codebase $C$ . Let $\mathcal { R }$ be a set of rewrite rules2 that allows to insert and repair bugs. We train $D _ { \theta }$ to be able to recognize the “hardest” possible rewrites that could be applied on our codebase $C$ For this, we consider the loss $\mathcal { L } _ { D _ { \theta } }$ of $D _ { \theta }$ on a rewritten code snippet $\mathrm { s } [ \rho ] _ { \ell }$ , for which the model needs to predict the repairing rewrite $\langle \ell , \rho ^ { - 1 } \rangle$ . Formally, we want to minimize the objective
+
+$$
+E _ { \mathrm { s } \sim C } \left[ \operatorname* { m a x } _ { \langle \ell , \rho \rangle \in R _ { \mathrm { s } } ^ { \mathcal { R } } } \mathcal { L } _ { D _ { \theta } } \left( \mathrm { s } [ \rho ] _ { \ell } , \left. \ell , \rho ^ { - 1 } \right. \right) \right] .
+$$
+
+![](images/6a90afa1a44c13ced3e725f045bc326e6741157b1e8e404cd0b3127444e41f05.jpg)  
+Figure 1: BUGLAB overview: a selector model $S _ { \phi }$ decides which (bugintroducing) rewrite to apply to an input code snippet. Then a bug detector $D _ { \theta }$ tries to locate and repair the inserted bug (if one was inserted).
+
+However, for any useful detector the set of rewrites $R _ { \mathrm { s } } ^ { \mathcal { R } }$ is commonly very large or unbounded and computing the maximum over all $\langle \bar { \ell , } \rho \rangle \in R _ { \mathrm { s } } ^ { \mathcal { R } }$ is practically intractable. To address this, BUGLAB introduces a bug selector model $S _ { \phi }$ (with parameters $\phi _ { , }$ ), whose goal is to approximate the intractable $\mathrm { m a x } _ { \langle \ell , \rho \rangle \in R _ { \mathrm { s } } ^ { \mathcal { R } } } \mathcal { L } _ { D _ { \theta } } \left( \cdot \right)$ . We can then sample rewrites from $S _ { \phi }$ instead of computing the maximum. We denote this as $\langle \ell , \rho \rangle \sim S _ { \phi } ( s )$ and the overall BUGLAB training objective can be written as a min-max optimization problem:
+
+$$
+\operatorname* { m a x } _ { \phi } \operatorname* { m i n } _ { \theta } E _ { \mathrm { s } \sim C } \left[ E _ { \langle \ell , \rho \rangle \sim S _ { \phi } ( \mathrm { s } ) } \left[ \mathcal { L } _ { D _ { \theta } } \left( \mathrm { s } [ \rho ] _ { \ell } , \langle \ell , \rho ^ { - 1 } \rangle \right) \right] \right] .
+$$
+
+The two models $S$ and $D$ in BUGLAB are “symmetric” in the sense that they both predict rewrites on code snippets, and only differ in their objectives — one aiming to introduce bugs and one aiming to repair them. In practice, we can and do use the same architecture to model both $S$ and $D$ , which we will discuss in the next section. At test time, we discard $S$ and only use the trained detector $D$ to locate and repair bugs.
+
+# 3 Neural Models
+
+In this section, we discuss how we represent code in BUGLAB and the neural models we use to learn how to rewrite code in the selector and detector models.
+
+Code Representation We consider source code as a set of entities $v _ { i } ~ \in ~ V$ which relate to each other with a set of typed relations $e _ { k } \in E$ , where a relation $e _ { k } = ( v _ { i } , r , v _ { j } )$ denotes a relationship between entities $v _ { i }$ and $v _ { j }$ with type $r$ . The entities and relations can be thought as a heterogeneous graph $G = ( V , E )$ . The choice of code entities and their relationships is a form of high-level feature extraction. We discuss concrete entities and relationships for Python in Sec. 4. We also define a projection function $\mathbb { P } _ { t o k }$ that accepts $V$ and $E$ and returns a sequence $V _ { t o k }$ of the token entities in $V$ with the nodes appearing in relations in $E$ deterministically mapped to elements of $V _ { t o k }$ , i.e. $E _ { t o k } = \{ ( p ( v _ { i } ) , r , p ( \hat { v _ { j } } ) ) \}$ , where $p$ maps the entities in $V$ to $V _ { t o k } . \mathbb { P } _ { t o k }$ will be used for relational transformer models.
+
+To learn a neural representation of the code entities $v _ { i }$ , first we define an embedding function $e ( v _ { i } )$ which maps the content of each entity to an initial $D$ -dimensional representation. Throughout this work — similar to Allamanis et al. [4] and other previous work — we deterministically split the string representation of each node into subtokens (e.g., fooBar is split into foo and bar), embed them through a learned embedding matrix, and use max pooling to get a single vector. We then “contextualize” the entity representations within $G$ using one of two models: a MLP-based GNN model with max message aggregation and the GREAT relational transformer of Hellendoorn et al. [13] over the token sequence and relations $V _ { t o k } , E _ { t o k } = \mathbb { P } _ { t o k } ( V , E )$ . GREAT uses both positional encodings and the projected relations in $E _ { t o k }$ . See Appx. A for detailed architecture descriptions. Other models to compute entity representations can be used, but were not explored in this work.
+
+We use $\mathbfit { \Delta } \mathbf { r } _ { \ell }$ to denote the computed vector representation of the entity at location $\ell$ , independent of the model used to produce it. We use these representations to define our code rewriting models.
+
+Probabilistic Code Rewriting Models Both bug selection and bug detection require to model the probability of applying a specific rewrite at a location in a code snippet s, either to introduce or repair a bug. For this, we factorize this task into localization and rewrite-given-location models, i.e.
+
+$$
+p \left( \langle \ell , \rho \rangle \mid \mathrm { s } , R _ { \mathrm { s } } ^ { \mathcal { R } } \right) = p _ { l o c } { \big ( } \ell \mid \mathrm { s } , R _ { \mathrm { s } } ^ { \mathcal { R } } { \big ) } p _ { r e w } { \big ( } \rho \mid \ell , \mathrm { s } , R _ { \mathrm { s } } ^ { \mathcal { R } } { \big ) } .
+$$
+
+We model $p _ { l o c }$ as a probability distribution over the relevant locations $\{ \ell \mid \langle \ell , \rho \rangle \in R _ { \mathrm { s } } ^ { \mathcal { R } } \} \cup \{ \mathrm { N o B U G } \}$ , where NoBug is a special location used to indicate that the code is not buggy. In practice, we implement this similar to a pointer net [19] using the representations $\mathbfit { \Delta } \mathbf { r } _ { \ell }$ (see Appx. A for details).
+
+To select rewrites, we use rewrite type-specific learnable rule score functions $w _ { \rho } \left( r _ { \ell } , \mathcal { M } _ { \rho } ( \mathrm { s } , \ell ) \right)$ . This function maps a vector representation of an entity $\mathbf { \Delta } _ { \mathbf { \lambda } ^ { \mathbf { r } } \ell }$ and potential additional metadata onto a scalar score. The rule-specific metadata $\mathcal { M } _ { \rho } ( \mathrm { s } , \ell )$ is defined for some rewrites, e.g. containing representations of other entities that could be used in the location $\ell$ . We will discuss three concrete rule score functions in Sec. 4. The rewrite probability distribution $p _ { r e w }$ is then modeled by a softmax over the scores of all applicable rewrites at a target location $\ell$ , i.e.
+
+$$
+p _ { r e w } \left( \rho \mid \ell , \mathbf { s } , R _ { \mathbf { s } } ^ { \mathcal { R } } \right) = \operatorname * { s o f t m a x } _ { \langle \ell , \rho ^ { \prime } \rangle \in R _ { \mathbf { s } } ^ { \mathcal { R } } } \left( w _ { \rho ^ { \prime } } \left( r _ { \ell } , \mathcal { M } _ { \rho ^ { \prime } } ( \mathbf { s } , \ell ) \right) \right) .
+$$
+
+# 4 A Python Implementation
+
+This section presents an implementation of BUGLAB for Python called PYBUGLAB. PYBUGLAB currently tackles a large subset of “stupid simple bugs” [16]. Fixing these bugs requires small changes to the code, but commonly has significant impact on code correctness. Such bugs may be thought as a form of a typographical mistake or a copy-paste error, and are often relatively hard to locate by humans but obvious after the fact. They are also quite common, as observed in the empirical statistics of Karampatsis and Sutton [16] and Just et al. [14]. Future work may focus on a broader set of rewrite rules or even learnable rewrites, but as we will observe in Sec. 5 more work is needed towards this. Almost all ideas in PYBUGLAB transfer straightforwardly to other programming languages other than Python, but would require some engineering effort to implement.
+
+PYBUGLAB Code Entities and Relations In this work, we follow related literature (see Sec. 6 for more) and extract entities and relationships that are readily available by tokenizers, parsers, existing simple program analyses, or other Python-specific program analysis tools. The complete list of entities and relationships can be found in Appx. B and include syntactic entities and relations, relations about the intraprocedural data and control flow, types, and documentation. Some notable entities include SyntaxNodes, Tokens, and Symbols (references to variables and functions). Fig. 4 in Appx. B shows a graph of the entities and relationships of the snippet in Fig. 2.
+
+![](images/6fa04aa00a25535c0128e4a64746beb8ef02776ba155a61e8b37f97000e3c308.jpg)  
+Figure 2: Code snippet and rewrites available to PYBUGLAB.
+
+# 4.1 Bug-Inducing PYBUGLAB Rewrite Rules
+
+PYBUGLAB focuses on four common kinds of bugs. Fig. 2 shows a code snippet and the rewrites allowed for each location, which number 63 even for this small example.
+
+Variable Misuse Originally defined by Allamanis et al. [3] as a Cloze test for source code, Vasic et al. [30] and Hellendoorn et al. [13] reformulated the task to localizing a variable misuse bug (if any) within a snippet and repairing it. PYBUGLAB uses the latter representation. Variable misuse bugs are common, with $1 2 . 8 \AA - 1 4 . 8 \%$ found in the ManySStuBs4J corpus [16] and about $6 \%$ of them caught during Java compilation in the Google build system [28]. To insert and repair variable misuse bugs, PYBUGLAB supports variable-swapping rewrites, such as in locations $l _ { 1 }$ , $l _ { 3 }$ and $l _ { 4 }$ (amongst others) in Fig. 2. To score a variable-swapping rewrite, we use the representation of the rewrite location $\mathbfit { \Delta } \mathbf { r } _ { \ell }$ along with the representation $\mathbf { \Delta } _ { r _ { \sigma } }$ of a variable Symbol $\sigma$ that could replace the current variable, i.e. is in-scope and has been defined before $\ell$ . The rule score function $w _ { \rho }$ for replacing the variable at $\ell$ with the symbol $\sigma$ is then computed as the inner product $\boldsymbol { r } _ { \ell } ^ { \top } \boldsymbol { r } _ { \sigma }$ .
+
+Argument Swapping (or Argument Selection) First coined by Rice et al. [26], it refers to swapping the arguments of a function invocation, e.g. in $l _ { 6 }$ of Fig. 2. Rice et al. [26] and DeepBugs [22] tackled this problem when all arguments are single identifiers. PYBUGLAB extends this to swapping arbitrary argument expressions. The rule score function $w _ { \rho }$ for an argument swapping rewrite is a two-layer MLP applied to the concatenation of the output representations of the representation of the parameter and the to-be-swapped arguments arg1, and arg2: MLP $\left( [ r _ { \mathrm { p a r a m s } } , r _ { \mathrm { a r g 1 } } , r _ { \mathrm { a r g 2 } } ] \right)$ .
+
+Wrong Operator Corrupting operators has a long history in mutation testing [14]. Detecting incorrect operators with deep learning was first tackled by DeepBugs [22] by using learnable embeddings of operators, operands and literals for arithmetic and comparison operators. DeepBugs focused only on binary operators. In PYBUGLAB we tackle all binary operators, including Boolean, arithmetic and comparison operators and two unary operators: logical and arithmetic negation. Locations $l _ { 1 1 }$ , $l _ { 1 4 }$ , $l _ { 1 6 }$ , and $l _ { 2 0 }$ in Fig. 2 are rewrites related to wrong operators. The rule score function $w _ { \rho }$ for an operator rewrite again uses an inner product, $\boldsymbol { r } _ { \ell } ^ { \top } \boldsymbol { r } _ { \mathtt { \diamond p } }$ , where $\pmb { r } _ { \tt o p }$ is a learned embedding for operator op. Note that we rewrite operators only to compatible operators (e.g. $<$ to $>$ but not $^ +$ ).
+
+Wrong Literal Corrupting operands, and specifically, literals appearing in the source code, is also a common strategy in mutation testing. As in mutation testing, PYBUGLAB handles a limited number of commonly used literals, allowing rewrites to replace integer literals within the set of $- 2 , - 1 , 0 , 1 , 2$ and swapping the Boolean literal True with False and vice versa. The scoring function is identical to the operator rewrite, using a learnable embedding ${ \bf { r } } _ { \mathrm { { 1 i t } } }$ for each literal lit.
+
+# 4.2 PYBUGLAB Rewrite Rules for Data Augmentation
+
+We additionally consider more rewrite rules that are not meant to change the program semantics, using them as a form of data augmentation. This is in spirit similar to ideas in computer vision where images are transformed (e.g. rotated, cropped) but maintain their original content. Such rewrites
+
+Require: Code dataset $C$ , initial detector/selector model parameters $\theta ^ { ( 0 ) }$ , $\phi ^ { ( 0 ) }$
+
+1: for meta-epoch $i = 0$ to $I$ do   
+2: // Create dataset of buggy programs:   
+3: $C _ { D } ^ { ( i ) } \gets \left\{ \left( \mathrm { s } [ \rho ] _ { \ell } , \left. \ell , \rho ^ { - 1 } \right. \right) \mid \mathrm { s } \in C , k \mathrm { \ s a m p l e s \ } \left. \ell , \rho \right. \sim S _ { \phi ^ { ( i ) } } ( \mathrm { s } ) \right\}$   
+4: $\theta ^ { ( i + 1 ) } $ update $\theta ^ { ( i ) }$ by training $D$ on $C _ { D } ^ { ( i ) }$   
+5: // Create dataset of hard-to-detect bugs:   
+6: $\begin{array} { r } { C _ { S } ^ { ( i ) } \gets \left\{ \left( \mathrm { s } , \mathrm { a r g } \operatorname* { m a x } _ { \langle \ell , \rho \rangle \in R _ { \mathrm { s } } ^ { \mathcal { R } } } \left( \mathcal { L } _ { D _ { \theta ^ { ( i + 1 ) } } } \left( \mathrm { s } [ \rho ] _ { \ell } , \langle \ell , \rho ^ { - 1 } \rangle \right) \right) \right) \mid \mathrm { s } \in C \right\} } \end{array}$   
+7: $\phi ^ { ( i + 1 ) } $ update $\phi ^ { ( i ) }$ by training $S$ on $C _ { S } ^ { ( i ) }$
+
+have been shown to yield adversarially robust models of code [23]. Although our goal is not to provide adversarial robustness, we believe that such rewrites can help generalization. PYBUGLAB implements the following rewrites for this purpose:
+
+• Variable Renaming renames a local variable to a random name not already in scope. • Comment Deletion removes code comments, including docstrings and inline comments. Such comments commonly contain natural language information that is useful for code comprehension, but usually do not affect program semantics. • Comparison Expression Mirroring swaps the two sides of a comparison operator and changes it appropriately. For example, $\mathtt { a } < \mathtt { b }$ is transformed to $\mathtt { b } > \mathtt { a }$ . Note that in cases such as $\mathbf { f } \circ \circ ( ) \ < \ \mathsf { b a r } ( )$ , this will change the order of execution of foo and bar, possibly altering program semantics. • If-Else Branch Swapping negates the test condition of an if-else statement or a ternary expressions using DeMorgan’s law and swaps the then body with the else body.
+
+# 4.3 Implementation Details
+
+To make the training computationally tractable we approximate Eq. 1. A simplified, sequential version of our training procedure is shown in Alg. 1. Intuitively, we alternate between training the two models, as the (discrete) sampling of rewrite rules in the selector models precludes direct endto-end training. We first use the current state of the selector model to generate “hard” samples and train the detector model on these samples (we always include the unmodified (i.e., NoBug case) as a sample). Then, we use the loss of the detector model to identify those generated samples that were hardest to detect and train the selector model to produce such samples.
+
+In practice, we implemented the training procedure as a system of asynchronously communi$C _ { D / S } ^ { ( 0 ) } , \bar { C } _ { D / S } ^ { ( 1 ) } , \dots$ , and all of the described steps happen in parallel. We do not use “generations”of datasets, but instead use two constantly updated “pools” of training data, one state of the corresponding data pool. We remove samples from the data pool once they have been sampled $\nu$ times for use in training, in spirit similar to replay buffers in reinforcement learning. In our experiments, $\nu$ was set to 4. We regularly (in separate, concurrent processes) take snapshots of the the current state of the $D$ and $S$ models to generate new elements that are updated to the data pools, matching the procedure described in Alg. 1. We approximate the arg max in line 6 by only considering the $k$ samples chosen in line 3 for each input program. During training of $S$ , we then mask out the unobserved choices before computing the loss.
+
+# 5 Evaluation
+
+We now discuss our new dataset and evaluate PYBUGLAB. We $\divideontimes$ . . . . . . . . . .highlight. . . . .key . . . . . . . .results.
+
+Datasets To train PYBUGLAB we retrieve the 4k most downloaded packages in the Python package index (PyPI) and take $3 . 4 \mathrm { k }$ of them as training packages, using the rest for test purposes. During training, PYBUGLAB installs each package along with all its dependencies. Installing all the dependencies is important for extracting the entities and the relations beyond local syntactic ones (e.g. type inference, method resolution). For each file, PYBUGLAB checks if it is a duplicate of a file that has already been seen in the training following the method of Allamanis [1] and runs all the relevant program analyses to extract the entities and relationships in each function. When we use additional rewrites for data augmentation, these are applied at the input of the PYBUGLAB pipeline as a form of pre-processing. Following Alg. 1, the bug selector $S$ selects $k = 5$ bugs to introduce, rewrites the source code text, and then the program analyses extract the new entities and relationships for the rewritten code snippets. The initial and rewritten code snippets are then used to create the training data for the detector and selector models.
+
+We use two testsets to measure performance. First, we create RANDOMBUGS, a testset of 761 445 snippets derived from functions from the $6 0 0 \mathrm { P y P I }$ test packages (not seen during training). For each function we find within these packages we add it to the dataset along with 9 rewritten functions with a randomly inserted bug. On average graphs have 260 nodes, 601 edges, 25 rewrite locations, and 130 possible rewrites. We also collect a testset of real bugs. Although we conjecture that, in practice, the vast majority of bugs like those discussed in Sec. 4.1 are fixed when developers locally test their software, a few of those slip and then are fixed across different revisions checked into a version control systems. We have crawled the accessible repositories of all $2 8 5 \mathrm { k }$ packages in the Python Package Index (PyPI), collected and manually filtered bugs captured by the rewrites from Sec. 4.1. $\divideontimes$ . . . . .This. . . . . .new . . . . . . . . .dataset, . . . . . . . . . . . . . . .PYPIBUGS,. . . . . . . . . .contains. . . . . . .2374 . . . . . . . . . . . . .real-world,. . . . . . .small . . . . . . .bugs. We describe the data collection process in detail in Appx. D. In addition, we consider PYPIBUGS-PostFix: the examples from PYPIBUGS after a bug was fixed - we believe these samples are very likely to not contain any bugs anymore. We publish the dataset at https://www.microsoft.com/en-us/download/103554 and include it in the supplementary material.
+
+# 5.1 Quantitative Evaluation
+
+Our first experiment aims to evaluate whether the BUGLAB training framework yields more precise bug detectors. We consider two model architectures, using either GNNs or the GREAT transformer to compute embeddings of code entities (architecture details and hyperparameter choices can be found in Appx. A). We use four different training strategies: “supervised” is training only a bug detector on a fixed dataset of 1 million functions from the $3 . 4 \mathrm { k }$ training packages with randomly inserted bugs. “Random Selector” refers to a variant of PYBUGLAB using a bug selector model that uniformly at random picks a rewrite to insert bugs. Finally, PYBUGLAB and PYBUGLAB $+ \mathrm { A u g }$ use our framework from Sec. 2, with the latter also using additional rewrites to augment our code corpus. For the fully supervised model, we train with early stopping over a validation set; the other models are trained for a fixed number of 300 epochs (with $2 0 0 \mathrm { k }$ training samples per epoch) for the bug detector3 and the last detector model is used for evaluation.
+
+Table 1: Accuracies $( \% )$ for different training strategies and model architectures on RANDOMBUGS.   
+
+<table><tr><td rowspan="3"></td><td colspan="6">RANDOMBUGS</td></tr><tr><td></td><td>GNN</td><td></td><td></td><td>GREAT</td><td></td></tr><tr><td>Joint</td><td>Loc</td><td>Repair</td><td>Joint</td><td>Loc</td><td>Repair</td></tr><tr><td>Supervised</td><td>62.4</td><td>73.6</td><td>81.2</td><td>51.0</td><td>61.9</td><td>76.3</td></tr><tr><td>Random Selector</td><td>69.4</td><td>79.6</td><td>84.0</td><td>63.9</td><td>73.6</td><td>82.0</td></tr><tr><td>PYBUGLAB</td><td>69.6</td><td>80.4</td><td>84.2</td><td>64.0</td><td>74.3</td><td>82.3</td></tr><tr><td>PYBUGLAB +Aug</td><td>70.3</td><td>81.1</td><td>84.5</td><td>65.3</td><td>75.3</td><td>82.5</td></tr></table>
+
+Effectiveness of BUGLAB Training We first consider the performance of different models on the synthetic RANDOMBUGS dataset. Tbl. 1 shows the accuracy of predicting a full bug repair correctly (“Joint”) and analogous to Eq. 2 break this up into a localization accuracy (“Loc”) of predicting the correct location (or NoBug for correct examples) and a repair accuracy (“Repair”) for selecting the correct rewrite given the buggy location.
+
+We observe that $\divideontimes$ . . . . . . . . . . . . . . . . . . . . .BUGLAB-training. . . . . . .leads. . . .to . . . . . . .more. . . . . . . .robust. . . . . .bug . . . . . . . . . . .detectors. . . . . . . . . . . . .compared. . .to. . . . . . . .other methods .......... for both GNNs and GREAT. Random selector models — a form of data augmentation — improve performance over supervised methods but mostly on in-distribution RANDOMBUGS samples. As expected, $\divideontimes$ . . . . . . . . . . . . .augmenting. . . . .the . . . . . .code. . . . . . . . .dataset. . . . . . .helps . . . . . . . . . . . . . . . . .generalization, but does not make a substantial difference. Expanding the kinds of rewrites used to augment the data and learning to select them may improve performance in the future.
+
+Table 2: Results for different training strategies and model architectures on PYPIBUGS.   
+
+<table><tr><td></td><td colspan="6">PYPIBUGS</td><td colspan="4">PYPIBUGS-PostFix</td></tr><tr><td></td><td colspan="3">GNN</td><td colspan="3">GREAT</td><td colspan="2">GNN</td><td colspan="2">GREAT</td></tr><tr><td></td><td>Joint</td><td>Loc</td><td>Repair</td><td>Joint</td><td>Loc</td><td>Repair</td><td>Loc</td><td>Joint AUC</td><td>Loc</td><td>Joint AUC</td></tr><tr><td>Supervised</td><td>20.0</td><td>28.4</td><td>61.8</td><td>16.8</td><td>25.8</td><td>58.6</td><td>17.8</td><td>0.087</td><td>20.7</td><td>0.044</td></tr><tr><td>Random Selector</td><td>21.2</td><td>27.0</td><td>69.2</td><td>20.6</td><td>26.8</td><td>67.2</td><td>47.5</td><td>0.108</td><td>52.5</td><td>0.117</td></tr><tr><td>PYBUGLAB</td><td>24.2</td><td>31.3</td><td>70.7</td><td>24.0</td><td>32.8</td><td>67.9</td><td>32.9</td><td>0.160</td><td>28.6</td><td>0.140</td></tr><tr><td>PYBUGLAB +Aug</td><td>26.4</td><td>33.5</td><td>72.0</td><td>23.2</td><td>29.7</td><td>68.8</td><td>32.6</td><td>0.187</td><td>48.2</td><td>0.129</td></tr></table>
+
+Table 3: Localization and Repair Accuracy $( \% )$ per bug kind for the PYBUGLAB +Aug model.   
+
+<table><tr><td rowspan="3">Bug Type</td><td colspan="4">RANDOMBUGS</td><td colspan="4">PYPIBUGS</td></tr><tr><td colspan="2">GNN</td><td colspan="2">GREAT</td><td colspan="2">GNN</td><td colspan="2">GREAT</td></tr><tr><td>Loc</td><td>Repair</td><td>Loc</td><td>Repair</td><td>Loc</td><td>Repair</td><td>Loc</td><td>Repair</td></tr><tr><td>Argument Swapping</td><td>85.0</td><td>57.3</td><td>65.5</td><td>57.2</td><td>33.2</td><td>73.9</td><td>24.3</td><td>72.7</td></tr><tr><td>Wrong Assign Op</td><td>96.1</td><td>99.1</td><td>94.5</td><td>98.6</td><td>20.0</td><td>68.9</td><td>14.0</td><td>58.1</td></tr><tr><td>Wrong Binary Op</td><td>83.0</td><td>85.2</td><td>77.3</td><td>81.4</td><td>27.2</td><td>54.3</td><td>36.6</td><td>43.7</td></tr><tr><td>Wrong Boolean Op</td><td>71.8</td><td>99.5</td><td>43.6</td><td>99.5</td><td>27.6</td><td>96.9</td><td>15.7</td><td>97.2</td></tr><tr><td>Wrong Comparison Op</td><td>83.9</td><td>79.3</td><td>80.0</td><td>76.4</td><td>33.7</td><td>66.1</td><td>31.1</td><td>53.5</td></tr><tr><td>Wrong Literal</td><td>71.7</td><td>74.7</td><td>66.6</td><td>71.6</td><td>21.6</td><td>78.4</td><td>17.9</td><td>79.5</td></tr><tr><td>Variable Misuse</td><td>84.9</td><td>88.4</td><td>78.2</td><td>86.3</td><td>35.3</td><td>70.5</td><td>34.0</td><td>69.4</td></tr><tr><td>NoBUG</td><td>53.8</td><td></td><td>62.5</td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+Furthermore, $\ast { \mathrm { l o u g } } .$ . . . . . . . . . . . . . .localization . . .is . . . . . . .much . . . . . . . .harder. . . . . .than . . . . . . . .repair . . .at . .a . . . . . . .given . . . . . . . . . .location. This is somewhat expected: there are many more candidate locations compared to potential repairs at a given location. However, this suggests that research should focus on the localization problem rather than repair.
+
+We now turn to the results on PYPIBUGS, shown in Tbl. 2, which also includes the accuracy of choosing the special NoBug location on the PYPIBUGS-PostFix dataset, as well as the area under the precision recall curve for the results on both PYPIBUGS and PYPIBUGS-PostFix.
+
+We find that $\divideontimes$ . . . . . . . . . .detecting. . . . .and. . . . . . . . . . . .repairing . . . . . . . . .real-life. . . . . . .bugs . .is. . . . . . . . . . . . . . .significantly. . . . . . . .harder. . . . . .than. . . . . . . . . . .handling . . . . . . . . . . . .randomly . . . . . . . . .inserted. . . . . .bugs. As PYBUGLAB models trained using a learned bug selector outperform those using a “Random Selector”, we speculate that the learned selector avoids generating easy-to-detect bugs, focusing the detector model on recognizing deeper semantic patterns. Despite this, improvements in RANDOMBUGS often correlate with improvements in PYPIBUGS. This is encouraging: collecting PYPIBUGS-like datasets is costly; corpora with random bugs can help measure relative improvements to some extent. Finally, we find that $\divideontimes$ . . . . . . . . . . . . . .recognizing . . . . . . . . . . . . .non-buggy . . . . . . . . . .samples. . .is . . . . . .very . . . . . .hard, and in particular, does not always profit from training in PYBUGLAB.
+
+In our qualitative analysis (Sec. 5.2), we observed that the models raised some confident but incorrect warnings at very “odd” locations. However, these warnings were different across models. We have tested an ensembling strategy averaging the output probabilities of five separately trained GNN models. This results in localization and repair accuracies of $8 3 . 0 \%$ and $8 5 . 4 \%$ on RANDOMBUGS (vs. $8 1 . 1 \%$ and $8 4 . 5 \%$ ) and $3 4 . 4 \%$ and $7 2 . 2 \%$ on PYPIBUGS (vs. $3 3 . 5 \%$ and $7 2 . 0 \%$ ). As we discuss in Sec. 5.2 finding the cause of the “spurious” warnings is important future work.
+
+Per-Bug Evaluation To better understand which bugs are hard to detect, we break down the results the best-performing PYBUGLAB $+ \mathrm { A u g }$ models on RANDOMBUGS by type of bug in Tbl. 3. We observe that incorrect literals are some of the hardest bugs to detect. Incorrect assignment operators $( e . g . = \mathrm { a n d } + = )$ ) are easy to detect in RANDOMBUGS, but significantly harder in PYPIBUGS. This may be attributed to class imbalance, with simple assignment $( = )$ being the majority class. $\divideontimes$ Detecting . . . . . . . . . . . . . .if .a. . . . . . . . .snippet. . . . .has . .a . . . . .bug . . .or . . . .not. . . . . . . .seems . . .to . . .be. . . .the. . . . . . . . .hardest. . . . . .task:. . . .no. . . . . . . .model . . . . . . . . . .achieves. . . . . . . . . . .accuracy. . . . . . . . .beyond. $6 3 \%$ .
+
+We note that in our experiments, GNNs-based models seem to often outperform GREAT, somewhat contradicting the results of Hellendoorn et al. [13]. We have performed substantial additional experiments to investigate and verify these results, cf. Sec. A.2. This may have to do with the performance of these models on long sequences or that the GNN has access to more fine-grained information, instead of relations over the projected token sequences. For example, this could be attributed to the lack of syntax and symbol nodes in the representation used in GREAT. Nevertheless, GREAT is noticeably better ( $6 2 . 5 \%$ vs. $5 3 . 8 \%$ ) at detecting NoBug and locating wrong binary operators in PYPIBUGS.
+
+Table 5: Bug distribution $( \% )$ in different datasets   
+
+<table><tr><td>Bug Kind</td><td>PYPIBUGS</td><td>RANDOMBUGS</td><td>Selector Samples</td></tr><tr><td>Argument Swapping</td><td>11.9</td><td>8.4</td><td>23.8</td></tr><tr><td>Wrong Assignment</td><td>1.9</td><td>8.5</td><td>5.3</td></tr><tr><td>Wrong Binary Operator</td><td>3.4</td><td>2.4</td><td>2.3</td></tr><tr><td>Wrong Boolean Operator</td><td>8.1</td><td>2.2</td><td>6.4</td></tr><tr><td>Wrong Comparison Operator</td><td>17.1</td><td>8.2</td><td>7.4</td></tr><tr><td>Wrong Literal</td><td>3.7</td><td>11.6</td><td>12.4</td></tr><tr><td>Variable Misuse</td><td>53.8</td><td>58.6</td><td>42.5</td></tr></table>
+
+Bug Selector Performance To understand how training of the bug selector proceeds, we perform two experiments. In our first experiment, we take a snapshot of the selector model during training of the PYBUGLAB $+ \mathrm { A u g }$ (GNN) model every 24 hours, after an initial burn-in phase of 12 hours. We then generate 10000 buggy samples using each of these snapshots and then test a fixed model on each of these snapshots. The results of this are shown in Tbl. 4, using a fully trained PYBUGLAB $+ \mathrm { A u g }$ (GNN) model from another training run as a fixed model. We conclude that . . . . . . . . . . . . . . . . . . . . . . . . .PYBUGLAB succeeds. . . .in . . . . . . . . . .learning . . .to . . . . . . . . . .generate. . . . . . . .harder. . .to find ..........bugs, though we can observe the selector model trading off “harder-to-localize” and “harder-tofix” properties. Tests on other models show similar trends, confirming the robustness of this result.
+
+Table 4: Development of Performance on Bug Selector Samples   
+
+<table><tr><td>Training&#x27; Time</td><td>Joint</td><td>Loc</td><td>Repair</td></tr><tr><td>0.5 days</td><td>64.2</td><td>83.8</td><td>72.1</td></tr><tr><td>1.5 days</td><td>62.5</td><td>80.7</td><td>72.9</td></tr><tr><td>2.5 days</td><td>62.0</td><td>83.0</td><td>69.8</td></tr><tr><td>3.5 days</td><td>61.7</td><td>82.5</td><td>69.8</td></tr><tr><td>4.5 days</td><td>61.9</td><td>83.0</td><td>69.5</td></tr><tr><td>5.5 days</td><td>61.1</td><td>83.0</td><td>68.6</td></tr><tr><td>6.5 days</td><td>60.5</td><td>78.7</td><td>72.4</td></tr></table>
+
+In a second experiment, we compare the distribution of different bug kinds in PYPIBUGS and RANDOMBUGS with the distribution of bugs sampled from the final snapshot of our selector model from above. The results are shown in Tbl. 5, where we can see that a number of bugs (argument swapping, use of wrong literals and of assignment operators) are substantially over-represented, whereas mistakes in comparison operators and variable misuse are under-represented. This indicates that . . . . . . . . . . . . . . . . . . . . . . . . . .PYBUGLAB generates. . . . . .hard . . .to . . . . . .find, . . . .but. . . .not. . . . . . . . . . . . . .necessarily . . . . . . . . . .realistic . . . . . .bugs.
+
+Comparison to CuBERT Finally, we compare our models to CuBERT [15], which uses a masked language modeling objective to pre-train a BERT-like model and then learns bug detectors specific to a class of bugs (e.g., wrong binary operators) on top of this pre-trained model. Note that CuBERT detects $i f$ a bug exists but does not localize it. For the comparison, we create two sub-datasets of PYPIBUGS: PYPIBUGS-WrongOp contains the 501 samples that involve the binary operators supported by CuBERT, and PYPIBUGS-VarMisuse, which contains the 1278 bugs that involve variable misuses. We complete both of these datasets with 501 (resp. 1278) random NoBug code samples from our RANDOMBUGS, to match the 1:1 buggy/non-buggy distribution used in CuBERT’s training. Since CuBERT classification models focus on a single bug type, to compare to PYBUGLAB we mask out all code locations that do not correspond to a bug that could be detected by the corresponding CuBERT model. We then treat the prediction of the NoBug location as a “non-buggy” prediction and all other locations as a “buggy” prediction. For example, for the snippet in Fig. 2, only the locations $l _ { 2 }$ , $l _ { 1 1 }$ , $l _ { 1 4 }$ , $l _ { 1 6 }$ , and $l _ { 2 0 }$ and their corresponding rewrites are considered by PYBUGLAB for the comparison on PYPIBUGS-WrongOp.
+
+Tbl. 6 shows the results of comparing the released CuBERT snapshots with the PYBUGLAB +Aug GNN model. We observe that $\divideontimes$ . . . .the . . . . . . . . . . . . . . . . . . . . . . . . .PYBUGLAB models
+
+Table 6: Comparison with CuBERT [15]   
+
+<table><tr><td rowspan="2"></td><td colspan="3">CuBERT</td><td colspan="3">PYBUGLAB (GNN)</td></tr><tr><td>Prec</td><td>Recall</td><td>F1</td><td>Prec</td><td>Recall</td><td>F1</td></tr><tr><td>PYPIBUGs-WrongOp</td><td>0.764</td><td>0.251</td><td>0.378</td><td>0.730</td><td>0.764</td><td>0.746</td></tr><tr><td>PYPIBUGS-VarMisuse</td><td>0.632</td><td>0.403</td><td>0.493</td><td>0.740</td><td>0.840</td><td>0.787</td></tr></table>
+
+. . . . .have. . . . . . . . . . . . . . . .substantially . . . . . . .better. . . . . . .recall. . . . . .than. . . . . . . . . . . . . . . . . . .CuBERT-based . . . . . . . . .models, even though they were trained to detect more bug types. When calibrating the CuBERT models to have a recall equal to PYBUGLAB, heir precision drops substantially. In particular, on PYPIBUGS-WrongOp, it is reduced to 0.609, and
+
+1 def make_id(name):   
+2 $\mathbf { r } \ =$ get_rand_string(12)   
+3 if len(name) <= 22:   
+4 name $=$ name[:22]   
+5 return name $\textrm { + } \textrm { -- } \textrm { + } \textrm { \pmb { r } }$ (a) A wrong comparison operator bug (red box) in PYPIBUGS detected and repaired by the GNN PYBUGLAB +Aug models.
+
+1 def update(self, roomId,   
+2 title, \*\*request_params):   
+3 check_type(roomId, basestring)   
+4 check_type(roomId, basestring)   
+5 [...]
+
+(b) A variable misuse (red box) caught in an open-source project. GNN PYBUGLAB $+ \mathrm { A u g }$ suggests to rewrite roomId to title. The fixing pull request is found here.
+
+Figure 3: Bugs found by PYBUGLAB. Snippets reformatted and abbreviated to fit figure.
+
+on PYPIBUGS-VarMisuse, it is reduced to 0.613; in both cases, PYBUGLAB outperforms CuBERT substantially.
+
+# 5.2 Qualitative Inspection of Raised Warnings
+
+We now take a qualitative look at the raised warnings raised by PYBUGLAB. As example, Fig. 3a shows a sample of PYPIBUGS where the developer used an incorrect comparison operator. Once pointed to it, it is clear to a human that the truncation statement in line 4 has no effect (under the reasonable assumption that name is a string), and that a different comparison operator $( > )$ is necessary.
+
+To gain an understanding of the performance of PYBUGLAB on realistic data, we performed an indepth analysis of the cases flagged as bugs by our best-performing model on the code found within the 4k top PyPI packages. We observed a mixture of false positives with few previously unseen real-life bugs, matching the quantitative results in Tbl. 3. First, we find that the majority of the false positives are “incorrect literal” detections. This suggests that learning to detect such bugs is a hard problem. Furthermore, many literals serve as default “configurations” (e.g. the number of retries for a network request) and different values are not bugs. We posit that a large percentage of literal replacements the selector learns to make fall in this category.
+
+We also found that some repairs suggested by the model actually produce semantically equivalent code. For example, the model lacks knowledge that two variables refer to the same object in memory (aliasing), and so attempts to “repair” variable misuse bugs by switching between these. Other examples includes checking the return values of standard functions such as Python’s str.find, which returns $^ { - 1 }$ if the query string is not found. In such cases, PYBUGLAB often suggested to rewrite an if $\mathbf { x } \lrcorner \mathbf { f i n d } ( \mathbf { y } ) \ \ll \ - 1$ to if $\mathbf { x } \lrcorner \mathbf { f i n d } ( \mathbf { y } ) \ = - 1$ , which makes no difference in practice. These false negatives can be attributed to the fact that the bug selector model considers such changes as introducing bugs, even though they are not actually changing behavior. This suggests that for better results, the rewrite rules need to ensure that the rewrites are not semantics-preserving and represent bugs.
+
+Finally, some reported issues were sufficiently complex that it took us (the human authors) a couple of minutes of thought to conclude that a warning is spurious. Simultaneously, there are some warnings that are “obviously” incorrect to us, but the reasons why the neural models raise them is unclear. This highlights the importance of research on explainability techniques along with better ways to calibrate model confidence. The fact that selectors may introduce spurious “bugs” may also be affecting how the detector model learns. Ideas that have appeared in reinforcement learning, such as the one of Dennis et al. [8], may allow models to improve their performance in spite of spurious bugs.
+
+Overall, $\yen 123,456,7$ . . .of. . . . .the . . . . . .1000. . . . . . . . . . .reported . . . . . . . . . . .warnings . . . . . .were. . . . . . . .found . . .to . . .be. . . . . . . . . .real-life. . . . . . .bugs. Of these 19, we reported 11 on GitHub (6 already merged, 5 pending approval). See Appx. G for details. 3 other bugs had already been fixed between the version PYBUGLAB processed and the current version or the project was deprecated, whereas another 5 bugs are minor and we decided not to report them. One of the detected bugs is shown in Fig. 3b. Overall, most of the detected bugs appear within unit tests, logging, or exception handling, possibly because bugs there do not impact the core functionality of a project. However, given the number of such bugs we collected in PYPIBUGS, we believe that such bugs arise equally often in other code, but that they are detected and fixed more quickly.
+
+Although our analysis only forms a lower bound on the precision of PYBUGLAB and related methods, it suggests that there is still ample room for future improvements towards making machine learningbased bug detection and repair practically useful.
+
+# 6 Related Work
+
+Detecting bugs in source code has been researched since the early days of computing. Traditionally, bug detection is tackled as a formal task, where any code that cannot be proved to satisfy some correctness property may contain a bug. This is essential for security- and safety-critical bugs, but not for other — equally common — bugs. In the last decade, software engineering and programming language research have increasingly realized ambiguous information within code (e.g. variable names, comments) contains valuable information and using this information can yield valuable results [2]. The main premise is that patterns in source code, such as patterns in names, control, and data flow can be informative. This information can also be exploited to detect some bugs. For example, Ray et al. [24] noted that even simple language models tend to assign lower probability to buggy code.
+
+Multiple static analysis methods have been researched that combine some form of data-oriented bug detection. This ranges from language model-based tools, such as the early work of Wang et al. [32] to specification-mining tools such as the work of Eberhardt et al. [10]. BUGLAB is related to DeepBugs [22] which uses an MLP over a limited window of code tokens and train separate models to detect wrong operators, operands, and argument swappings. BUGLAB opts for a more structured representation of code and a single model. Allamanis et al. [3], Vasic et al. [30], Hellendoorn et al. [13] tackle variable misuse bugs (one of the kinds of bugs included in PYBUGLAB) but either by randomly introducing the bugs in code or using a Cloze-like test. Instead, BUGLAB opts for a selfsupervised approach and tackles a broader range of bugs. Concurrently to this work, Patra and Pradel [21] showed an alternative method for learning to generate realistic bugs. Dinella et al. [9] learn a supervised sequential model that performs graph transformations that replicate small edits in code (refactoring, introducing functionality, bug fixing, etc.). Their model — Hoppity — could serve as a learnable rewrite operation in BUGLAB in future work. Dynamic analysis methods have also been researched with promising results [31], but collecting representative dynamic traces over a diverse set of programs at scale (e.g. from the top Python packages used in this work) is practically impossible.
+
+BUGLAB is related to ideas around self-supervised learning recently explored in deep learning, computer vision, and NLP. In our case, we aim to train a bug detection model without using training data from real-life bugs. BUGLAB resembles ELECTRA [6], with the important difference that the rewrites to the input code go beyond single token replacement that need to respect strict constraints of programming languages (syntax, variable scopes) and the model is directly used for bug detection, rather than for pre-training. The main BUGLAB objective Eq. 1 also resembles GANs [12] with the exception that the objective is non-differentiable (introducing a bug alters the discrete data representation), the selector is a structured probabilistic code rewriting model, and that we are mainly interested in the bug detector (analogous to the discriminator) rather than the selector.
+
+# 7 Discussion and Conclusions
+
+Learned program analyses offer the promise to improve how we develop software. They also offer a great opportunity to study machine learning models that combine formal and probabilistic reasoning. Towards achieving these we presented BUGLAB, a self-supervised approach for learning program analyses, that improves upon baseline methods and detects bugs in real-life code. We also empirically show the limitations of existing bug-detecting machine learning methods, which suffer from impractical false-positive rates. Importantly, we show the large gap of performance of existing methods on corpora of randomly inserted bugs — commonly used in prior work — and real-life bugs.
+
+# Acknowledgements
+
+We want to thank Sebastian Nowozin and Marwin Segler for helpful discussions, Marwin Segler for comments on a draft of this work, and the anonymous reviewers for useful questions and suggestions. Finally, we would like to thank the contributors to the following open-source tools used: PyTorch [20], PyDriller [27], MessagePack, LibCST, Jedi, Kubernetes, Helm.
+
+References   
+[1] M. Allamanis. The adverse effects of code duplication in machine learning models of code. In Proceedings of the 2019 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software, pages 143–153, 2019.   
+[2] M. Allamanis, E. T. Barr, P. Devanbu, and C. Sutton. A survey of machine learning for big code and naturalness. ACM Computing Surveys (CSUR), 51(4):1–37, 2018.   
+[3] M. Allamanis, M. Brockschmidt, and M. Khademi. Learning to represent programs with graphs. In International Conference on Learning Representations (ICLR), 2018.   
+[4] M. Allamanis, E. Barr, S. Ducousso, and Z. Gao. Typilus: Neural type hints. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), pages 91–105. Association for Computing Machinery (ACM), 2020.   
+[5] T. Bachlechner, B. P. Majumder, H. H. Mao, G. W. Cottrell, and J. McAuley. Rezero is all you need: Fast convergence at large depth. arXiv preprint arXiv:2003.04887, 2020.   
+[6] K. Clark, M.-T. Luong, Q. V. Le, and C. D. Manning. ELECTRA: Pre-training text encoders as discriminators rather than generators. arXiv preprint arXiv:2003.10555, 2020.   
+[7] M. Cvitkovic, B. Singh, and A. Anandkumar. Deep learning on code with an unbounded vocabulary. In Machine Learning 4 Programming, 2018.   
+[8] M. Dennis, N. Jaques, E. Vinitsky, A. Bayen, S. Russell, A. Critch, and S. Levine. Emergent complexity and zero-shot transfer via unsupervised environment design. arXiv preprint arXiv:2012.02096, 2020.   
+[9] E. Dinella, H. Dai, Z. Li, M. Naik, L. Song, and K. Wang. Hoppity: Learning graph transformations to detect and fix bugs in programs. In International Conference on Learning Representations, 2019.   
+[10] J. Eberhardt, S. Steffen, V. Raychev, and M. Vechev. Unsupervised learning of API aliasing specifications. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation, pages 745–759, 2019.   
+[11] J. Gilmer, S. S. Schoenholz, P. F. Riley, O. Vinyals, and G. E. Dahl. Neural message passing for quantum chemistry. In International Conference on Machine Learning, pages 1263–1272, 2017.   
+[12] I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial networks. arXiv preprint arXiv:1406.2661, 2014.   
+[13] V. J. Hellendoorn, C. Sutton, R. Singh, P. Maniatis, and D. Bieber. Global relational models of source code. In International Conference on Learning Representations, 2020.   
+[14] R. Just, D. Jalali, L. Inozemtseva, M. D. Ernst, R. Holmes, and G. Fraser. Are mutants a valid substitute for real faults in software testing? In Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering, pages 654–665, 2014.   
+[15] A. Kanade, P. Maniatis, G. Balakrishnan, and K. Shi. Learning and evaluating contextual embedding of source code. In International Conference on Machine Learning (ICML), 2020.   
+[16] R.-M. Karampatsis and C. Sutton. How often do single-statement bugs occur? the ManySStuBs4J dataset. In Proceedings of the 17th International Conference on Mining Software Repositories, pages 573–577, 2020.   
+[17] J. Katz. Libraries.io Open Source Repository and Dependency Metadata, Jan. 2020. URL https://doi.org/10.5281/zenodo.3626071.   
+[18] Y. Li, D. Tarlow, M. Brockschmidt, and R. Zemel. Gated graph sequence neural networks. In International Conference on Learning Representations (ICLR), 2016.
+
+[19] S. Merity, C. Xiong, J. Bradbury, and R. Socher. Pointer sentinel mixture models. In International Conference on Learning Representations (ICLR), 2017.
+
+[20] A. Paszke, S. Gross, S. Chintala, G. Chanan, E. Yang, Z. DeVito, Z. Lin, A. Desmaison, L. Antiga, and A. Lerer. Automatic differentiation in PyTorch. 2017.   
+[21] J. Patra and M. Pradel. Semantic bug seeding: a learning-based approach for creating realistic bugs. In Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, pages 906–918, 2021.   
+[22] M. Pradel and K. Sen. DeepBugs: A learning approach to name-based bug detection. Proceedings of the ACM on Programming Languages, 2(OOPSLA):1–25, 2018.   
+[23] G. Ramakrishnan, J. Henkel, Z. Wang, A. Albarghouthi, S. Jha, and T. Reps. Semantic robustness of models of source code. arXiv preprint arXiv:2002.03043, 2020.   
+[24] B. Ray, V. Hellendoorn, S. Godhane, Z. Tu, A. Bacchelli, and P. Devanbu. On the ”naturalness” of buggy code. In 2016 IEEE/ACM 38th International Conference on Software Engineering (ICSE), pages 428–439. IEEE, 2016.   
+[25] V. Raychev, M. Vechev, and A. Krause. Predicting program properties from Big Code. In Principles of Programming Languages (POPL), 2015.   
+[26] A. Rice, E. Aftandilian, C. Jaspan, E. Johnston, M. Pradel, and Y. Arroyo-Paredes. Detecting argument selection defects. Proceedings of the ACM on Programming Languages, 1(OOPSLA): 1–22, 2017.   
+[27] D. Spadini, M. Aniche, and A. Bacchelli. PyDriller: Python framework for mining software repositories. In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering - ESEC/FSE 2018, pages 908–911, New York, New York, USA, 2018. ACM Press. ISBN 9781450355735. doi: 10.1145/3236024.3264598. URL http://dl.acm.org/citation. cfm?doid $\equiv$ 3236024.3264598.   
+[28] D. Tarlow, S. Moitra, A. Rice, Z. Chen, P.-A. Manzagol, C. Sutton, and E. Aftandilian. Learning to fix build errors with Graph2Diff neural networks. In Proceedings of the IEEE/ACM 42nd International Conference on Software Engineering Workshops, pages 19–20, 2020.   
+[29] H. Touvron, M. Cord, A. Sablayrolles, G. Synnaeve, and H. Jegou. Going deeper with image ´ transformers. arXiv preprint arXiv:2103.17239, 2021.   
+[30] M. Vasic, A. Kanade, P. Maniatis, D. Bieber, and R. Singh. Neural program repair by jointly learning to localize and repair. arXiv preprint arXiv:1904.01720, 2019.   
+[31] K. Wang and Z. Su. Blended, precise semantic program embeddings. In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation, pages 121–134, 2020.   
+[32] S. Wang, D. Chollak, D. Movshovitz-Attias, and L. Tan. Bugram: bug detection with n-gram language models. In Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering, pages 708–719, 2016.   
+[33] J. Wei, M. Goyal, G. Durrett, and I. Dillig. LambdaNet: Probabilistic type inference using graph neural networks. arXiv preprint arXiv:2005.02161, 2020.

parse/train/zOngaSKrElL/zOngaSKrElL_content_list.json

@@ -0,0 +1,1185 @@
+[
+    {
+        "type": "text",
+        "text": "Self-Supervised Bug Detection and Repair ",
+        "text_level": 1,
+        "bbox": [
+            240,
+            122,
+            756,
+            148
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Miltiadis Allamanis, Henry Jackson-Flux∗, Marc Brockschmidt Microsoft Research, Cambridge, UK {miallama, mabrocks}@microsoft.com ",
+        "bbox": [
+            281,
+            200,
+            717,
+            243
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            279,
+            535,
+            295
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Machine learning-based program analyses have recently shown the promise of integrating formal and probabilistic reasoning towards aiding software development. However, in the absence of large annotated corpora, training these analyses is challenging. Towards addressing this, we present BUGLAB, an approach for selfsupervised learning of bug detection and repair. BUGLAB co-trains two models: (1) a detector model that learns to detect and repair bugs in code, (2) a selector model that learns to create buggy code for the detector to use as training data. A Python implementation of BUGLAB improves by up to $30 \\%$ upon baseline methods on a test dataset of 2374 real-life bugs and finds 19 previously unknown bugs in open-source software. ",
+        "bbox": [
+            233,
+            310,
+            767,
+            448
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            473,
+            310,
+            491
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Detecting and repairing bugs in source code requires strong reasoning skills over formal structures (e.g. data and control flow) and ambiguous information (e.g. identifier names, coding idioms, and comments). Traditional program analyses are able to detect critical bugs through formal reasoning and combinatorial search, but need to be manually coded by experts. That is a lengthy and costly process, which misses the opportunity to use ambiguous information pervasive within code. ",
+        "bbox": [
+            174,
+            505,
+            825,
+            574
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Towards broadening the applicability of such methods, and utilizing ambiguous information, deep learning-based bug detection methods are being investigated [22, 3, 13]. These methods have the potential to further improve the engineering of software we rely on every day. However, many challenges in the area remain open, such as creating robust bug detection and repair methods that cover a wide range of common bugs in the absence of large supervised training corpora. Existing work focuses on randomly inserted bugs [22, 13], Cloze test proxy tasks [3], corpora of small code edits that may contain bugs [9] or build errors [28]. All these approaches rely on datasets of very limited size or ones known not to be representative of the characteristics of bugs found in real code. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            691
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose BUGLAB, a self-supervised approach that trains robust bug detectors by co-training a bug selector that learns to create hard-to-detect bugs (Sec. 2). For example, for a given code snippet with two well-named variables, a variable misuse bug may be easy to detect and repair, whereas an incorrect comparison operator might be significantly harder to identify. We propose a neural architecture for BUGLAB (Sec. 3) and implement it for Python (Sec. 4). Our implementation considers four broad classes of seemingly simple, yet hard-to-detect bugs and shows improved performance over training with randomly-inserted bugs on PYPIBUGS, a new, manually curated test set of 2374 real-life bugs (Sec. 5). Furthermore, we tested our trained models on popular open-source Python packages and identified 19 previously unreported bugs, though false positive rates of $\\sim 9 8 \\%$ remain impractical. We hope that creating machine learning methods that can detect these bugs early and assist developers will speed up software development and allow engineers to deliver more robust software. We release PyPIBugs and our code at https://github.com/ microsoft/neurips21-self-supervised-bug-detection-and-repair. ",
+        "bbox": [
+            174,
+            698,
+            825,
+            877
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 Self-Supervised Bug Detection ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            457,
+            107
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first introduce the concept of code rewriting, and then use it to define BUGLAB as a framework for self-supervised learning of bug detection and repair. ",
+        "bbox": [
+            174,
+            123,
+            825,
+            151
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Code Rewriting Rewriting is common within compilers and their optimizations, test-driven searchbased bug repair tools, mutation testing, and refactoring tools. Rewrites can be semantics-preserving (e.g. renamings of local variables), or semantics-altering (e.g. replacing $> = \\log ~ ! = )$ . ",
+        "bbox": [
+            174,
+            170,
+            826,
+            212
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $s$ denote the set of all syntax trees (not necessarily rooted in the start symbol of the language grammar). Syntax tree locations $\\ell \\in \\{ \\epsilon \\} \\cup \\mathbb { N } ^ { * }$ in a syntax tree $\\mathrm { s } \\in { \\mathcal { S } }$ are recursively defined, where $\\mathrm { s } _ { \\vert \\epsilon } = \\mathrm { s }$ and $\\mathrm { s } _ { | \\ell }$ for $\\ell = \\ell ^ { \\prime } \\circ i$ is the $i$ -th child of $\\mathrm { s } _ { \\vert \\ell ^ { \\prime } }$ (i.e. s|(2,3) denotes the third child of the second child of s). We define a rewrite rule $\\rho = ( \\mathrm { m } _ { \\rho } , \\mathrm { t } _ { \\rho } )$ as a pair of a matching function $\\operatorname { m } _ { \\rho } : S  \\{ t r u e , f a l s e \\}$ and a transformation function $\\mathrm { t } _ { \\rho } : { \\mathcal { S } }  { \\mathcal { S } }$ . The matching function $\\mathrm { m } _ { \\rho } ( \\mathrm { s } )$ yields true iff the rule $\\rho$ is applicable at the root of a subtree s. The transformation function can be applied to obtain a transformed syntax tree. For convenience, we define $\\mathrm { t } _ { \\rho } ( \\mathrm { s } ) = \\mathrm { s }$ iff $\\mathrm { m } _ { \\rho } ( \\mathrm { s } ) = f a l s e$ . We then write $\\rho ( \\mathrm { s } )$ to indicate the modification of a syntax tree s using $\\rho$ when possible, and otherwise the identity function. For reversible rewrite rules $\\rho$ , we denote the inverse rule as $\\rho ^ { - 1 }$ such that $\\rho ^ { - 1 } ( \\rho ( \\mathrm { s } ) ) = \\mathbf { \\dot { s } }$ holds. We discuss concrete rewrite rules $\\rho$ in Sec. 4. ",
+        "bbox": [
+            173,
+            218,
+            825,
+            358
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given a set of rewrite rules $\\mathcal { R }$ we define the set of “potential rewrites” in a syntax tree s as $R _ { \\mathrm { s } } ^ { \\mathcal { R } } =$ $\\{ \\langle \\ell , \\rho \\rangle \\mid \\rho \\in { \\mathcal { R } } , \\ell$ location in s, $, \\mathbf { m } _ { \\rho } ( \\mathbf { s } _ { | \\ell } ) = t r u e \\}$ . For each tuple $\\langle \\ell , \\rho \\rangle \\in R _ { \\mathrm { s } } ^ { \\mathcal { R } }$ , we use $\\mathrm { s } ^ { \\prime } = \\mathrm { s } [ \\rho ] \\varrho$ to denote the new syntax tree obtained by applying $\\rho$ at location $\\ell$ of s. In BUGLAB, we train models that use rewrites from $R _ { \\mathrm { s } } ^ { \\mathcal { R } }$ to insert and repair bugs. We will discuss such neural models in Sec. 3. ",
+        "bbox": [
+            173,
+            364,
+            825,
+            422
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "BUGLAB In BUGLAB, we are interested in selfsupervised training of a robust bug detector model $D _ { \\theta }$ with parameters $\\theta$ on an unannotated codebase $C$ . Let $\\mathcal { R }$ be a set of rewrite rules2 that allows to insert and repair bugs. We train $D _ { \\theta }$ to be able to recognize the “hardest” possible rewrites that could be applied on our codebase $C$ For this, we consider the loss $\\mathcal { L } _ { D _ { \\theta } }$ of $D _ { \\theta }$ on a rewritten code snippet $\\mathrm { s } [ \\rho ] _ { \\ell }$ , for which the model needs to predict the repairing rewrite $\\langle \\ell , \\rho ^ { - 1 } \\rangle$ . Formally, we want to minimize the objective ",
+        "bbox": [
+            173,
+            440,
+            550,
+            580
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/597426b766af16b530c3086ca1c3bf9cfa4fa1541fefff8ff73eda53f624e93e.jpg",
+        "text": "$$\nE _ { \\mathrm { s } \\sim C } \\left[ \\operatorname* { m a x } _ { \\langle \\ell , \\rho \\rangle \\in R _ { \\mathrm { s } } ^ { \\mathcal { R } } } \\mathcal { L } _ { D _ { \\theta } } \\left( \\mathrm { s } [ \\rho ] _ { \\ell } , \\left. \\ell , \\rho ^ { - 1 } \\right. \\right) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            228,
+            590,
+            495,
+            626
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/6a90afa1a44c13ced3e725f045bc326e6741157b1e8e404cd0b3127444e41f05.jpg",
+        "image_caption": [
+            "Figure 1: BUGLAB overview: a selector model $S _ { \\phi }$ decides which (bugintroducing) rewrite to apply to an input code snippet. Then a bug detector $D _ { \\theta }$ tries to locate and repair the inserted bug (if one was inserted). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            563,
+            434,
+            823,
+            618
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "However, for any useful detector the set of rewrites $R _ { \\mathrm { s } } ^ { \\mathcal { R } }$ is commonly very large or unbounded and computing the maximum over all $\\langle \\bar { \\ell , } \\rho \\rangle \\in R _ { \\mathrm { s } } ^ { \\mathcal { R } }$ is practically intractable. To address this, BUGLAB introduces a bug selector model $S _ { \\phi }$ (with parameters $\\phi _ { , }$ ), whose goal is to approximate the intractable $\\mathrm { m a x } _ { \\langle \\ell , \\rho \\rangle \\in R _ { \\mathrm { s } } ^ { \\mathcal { R } } } \\mathcal { L } _ { D _ { \\theta } } \\left( \\cdot \\right)$ . We can then sample rewrites from $S _ { \\phi }$ instead of computing the maximum. We denote this as $\\langle \\ell , \\rho \\rangle \\sim S _ { \\phi } ( s )$ and the overall BUGLAB training objective can be written as a min-max optimization problem: ",
+        "bbox": [
+            173,
+            645,
+            550,
+            714
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            714,
+            825,
+            757
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e53606b879b4d2a39b079f53ba9fb551d00be5442d4142c61a4ee1789a5f3c7d.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\phi } \\operatorname* { m i n } _ { \\theta } E _ { \\mathrm { s } \\sim C } \\left[ E _ { \\langle \\ell , \\rho \\rangle \\sim S _ { \\phi } ( \\mathrm { s } ) } \\left[ \\mathcal { L } _ { D _ { \\theta } } \\left( \\mathrm { s } [ \\rho ] _ { \\ell } , \\langle \\ell , \\rho ^ { - 1 } \\rangle \\right) \\right] \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            767,
+            681,
+            792
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The two models $S$ and $D$ in BUGLAB are “symmetric” in the sense that they both predict rewrites on code snippets, and only differ in their objectives — one aiming to introduce bugs and one aiming to repair them. In practice, we can and do use the same architecture to model both $S$ and $D$ , which we will discuss in the next section. At test time, we discard $S$ and only use the trained detector $D$ to locate and repair bugs. ",
+        "bbox": [
+            174,
+            809,
+            825,
+            880
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 Neural Models ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            328,
+            106
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we discuss how we represent code in BUGLAB and the neural models we use to learn how to rewrite code in the selector and detector models. ",
+        "bbox": [
+            174,
+            121,
+            823,
+            148
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Code Representation We consider source code as a set of entities $v _ { i } ~ \\in ~ V$ which relate to each other with a set of typed relations $e _ { k } \\in E$ , where a relation $e _ { k } = ( v _ { i } , r , v _ { j } )$ denotes a relationship between entities $v _ { i }$ and $v _ { j }$ with type $r$ . The entities and relations can be thought as a heterogeneous graph $G = ( V , E )$ . The choice of code entities and their relationships is a form of high-level feature extraction. We discuss concrete entities and relationships for Python in Sec. 4. We also define a projection function $\\mathbb { P } _ { t o k }$ that accepts $V$ and $E$ and returns a sequence $V _ { t o k }$ of the token entities in $V$ with the nodes appearing in relations in $E$ deterministically mapped to elements of $V _ { t o k }$ , i.e. $E _ { t o k } = \\{ ( p ( v _ { i } ) , r , p ( \\hat { v _ { j } } ) ) \\}$ , where $p$ maps the entities in $V$ to $V _ { t o k } . \\mathbb { P } _ { t o k }$ will be used for relational transformer models. ",
+        "bbox": [
+            173,
+            154,
+            825,
+            280
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To learn a neural representation of the code entities $v _ { i }$ , first we define an embedding function $e ( v _ { i } )$ which maps the content of each entity to an initial $D$ -dimensional representation. Throughout this work — similar to Allamanis et al. [4] and other previous work — we deterministically split the string representation of each node into subtokens (e.g., fooBar is split into foo and bar), embed them through a learned embedding matrix, and use max pooling to get a single vector. We then “contextualize” the entity representations within $G$ using one of two models: a MLP-based GNN model with max message aggregation and the GREAT relational transformer of Hellendoorn et al. [13] over the token sequence and relations $V _ { t o k } , E _ { t o k } = \\mathbb { P } _ { t o k } ( V , E )$ . GREAT uses both positional encodings and the projected relations in $E _ { t o k }$ . See Appx. A for detailed architecture descriptions. Other models to compute entity representations can be used, but were not explored in this work. ",
+        "bbox": [
+            173,
+            285,
+            826,
+            424
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use $\\mathbfit { \\Delta } \\mathbf { r } _ { \\ell }$ to denote the computed vector representation of the entity at location $\\ell$ , independent of the model used to produce it. We use these representations to define our code rewriting models. ",
+        "bbox": [
+            173,
+            430,
+            823,
+            458
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Probabilistic Code Rewriting Models Both bug selection and bug detection require to model the probability of applying a specific rewrite at a location in a code snippet s, either to introduce or repair a bug. For this, we factorize this task into localization and rewrite-given-location models, i.e. ",
+        "bbox": [
+            174,
+            464,
+            823,
+            507
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e13f1434c8e948af685abaf2f16c7854cbf7b41c33f14f6c15af31b5c452dc11.jpg",
+        "text": "$$\np \\left( \\langle \\ell , \\rho \\rangle \\mid \\mathrm { s } , R _ { \\mathrm { s } } ^ { \\mathcal { R } } \\right) = p _ { l o c } { \\big ( } \\ell \\mid \\mathrm { s } , R _ { \\mathrm { s } } ^ { \\mathcal { R } } { \\big ) } p _ { r e w } { \\big ( } \\rho \\mid \\ell , \\mathrm { s } , R _ { \\mathrm { s } } ^ { \\mathcal { R } } { \\big ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            512,
+            681,
+            532
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We model $p _ { l o c }$ as a probability distribution over the relevant locations $\\{ \\ell \\mid \\langle \\ell , \\rho \\rangle \\in R _ { \\mathrm { s } } ^ { \\mathcal { R } } \\} \\cup \\{ \\mathrm { N o B U G } \\}$ , where NoBug is a special location used to indicate that the code is not buggy. In practice, we implement this similar to a pointer net [19] using the representations $\\mathbfit { \\Delta } \\mathbf { r } _ { \\ell }$ (see Appx. A for details). ",
+        "bbox": [
+            173,
+            540,
+            828,
+            583
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To select rewrites, we use rewrite type-specific learnable rule score functions $w _ { \\rho } \\left( r _ { \\ell } , \\mathcal { M } _ { \\rho } ( \\mathrm { s } , \\ell ) \\right)$ . This function maps a vector representation of an entity $\\mathbf { \\Delta } _ { \\mathbf { \\lambda } ^ { \\mathbf { r } } \\ell }$ and potential additional metadata onto a scalar score. The rule-specific metadata $\\mathcal { M } _ { \\rho } ( \\mathrm { s } , \\ell )$ is defined for some rewrites, e.g. containing representations of other entities that could be used in the location $\\ell$ . We will discuss three concrete rule score functions in Sec. 4. The rewrite probability distribution $p _ { r e w }$ is then modeled by a softmax over the scores of all applicable rewrites at a target location $\\ell$ , i.e. ",
+        "bbox": [
+            173,
+            588,
+            826,
+            671
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/20ddd4085466fb2b98456820b56190ab15c90e6176666923f57291d6acdddecb.jpg",
+        "text": "$$\np _ { r e w } \\left( \\rho \\mid \\ell , \\mathbf { s } , R _ { \\mathbf { s } } ^ { \\mathcal { R } } \\right) = \\operatorname * { s o f t m a x } _ { \\langle \\ell , \\rho ^ { \\prime } \\rangle \\in R _ { \\mathbf { s } } ^ { \\mathcal { R } } } \\left( w _ { \\rho ^ { \\prime } } \\left( r _ { \\ell } , \\mathcal { M } _ { \\rho ^ { \\prime } } ( \\mathbf { s } , \\ell ) \\right) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            678,
+            678,
+            704
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 A Python Implementation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            720,
+            423,
+            738
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This section presents an implementation of BUGLAB for Python called PYBUGLAB. PYBUGLAB currently tackles a large subset of “stupid simple bugs” [16]. Fixing these bugs requires small changes to the code, but commonly has significant impact on code correctness. Such bugs may be thought as a form of a typographical mistake or a copy-paste error, and are often relatively hard to locate by humans but obvious after the fact. They are also quite common, as observed in the empirical statistics of Karampatsis and Sutton [16] and Just et al. [14]. Future work may focus on a broader set of rewrite rules or even learnable rewrites, but as we will observe in Sec. 5 more work is needed towards this. Almost all ideas in PYBUGLAB transfer straightforwardly to other programming languages other than Python, but would require some engineering effort to implement. ",
+        "bbox": [
+            173,
+            751,
+            825,
+            877
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "PYBUGLAB Code Entities and Relations In this work, we follow related literature (see Sec. 6 for more) and extract entities and relationships that are readily available by tokenizers, parsers, existing simple program analyses, or other Python-specific program analysis tools. The complete list of entities and relationships can be found in Appx. B and include syntactic entities and relations, relations about the intraprocedural data and control flow, types, and documentation. Some notable entities include SyntaxNodes, Tokens, and Symbols (references to variables and functions). Fig. 4 in Appx. B shows a graph of the entities and relationships of the snippet in Fig. 2. ",
+        "bbox": [
+            173,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/6fa04aa00a25535c0128e4a64746beb8ef02776ba155a61e8b37f97000e3c308.jpg",
+        "image_caption": [
+            "Figure 2: Code snippet and rewrites available to PYBUGLAB. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            158,
+            94,
+            831,
+            212
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            258,
+            825,
+            328
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 Bug-Inducing PYBUGLAB Rewrite Rules ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            343,
+            501,
+            358
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "PYBUGLAB focuses on four common kinds of bugs. Fig. 2 shows a code snippet and the rewrites allowed for each location, which number 63 even for this small example. ",
+        "bbox": [
+            174,
+            369,
+            823,
+            397
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Variable Misuse Originally defined by Allamanis et al. [3] as a Cloze test for source code, Vasic et al. [30] and Hellendoorn et al. [13] reformulated the task to localizing a variable misuse bug (if any) within a snippet and repairing it. PYBUGLAB uses the latter representation. Variable misuse bugs are common, with $1 2 . 8 \\AA - 1 4 . 8 \\%$ found in the ManySStuBs4J corpus [16] and about $6 \\%$ of them caught during Java compilation in the Google build system [28]. To insert and repair variable misuse bugs, PYBUGLAB supports variable-swapping rewrites, such as in locations $l _ { 1 }$ , $l _ { 3 }$ and $l _ { 4 }$ (amongst others) in Fig. 2. To score a variable-swapping rewrite, we use the representation of the rewrite location $\\mathbfit { \\Delta } \\mathbf { r } _ { \\ell }$ along with the representation $\\mathbf { \\Delta } _ { r _ { \\sigma } }$ of a variable Symbol $\\sigma$ that could replace the current variable, i.e. is in-scope and has been defined before $\\ell$ . The rule score function $w _ { \\rho }$ for replacing the variable at $\\ell$ with the symbol $\\sigma$ is then computed as the inner product $\\boldsymbol { r } _ { \\ell } ^ { \\top } \\boldsymbol { r } _ { \\sigma }$ . ",
+        "bbox": [
+            173,
+            404,
+            826,
+            544
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Argument Swapping (or Argument Selection) First coined by Rice et al. [26], it refers to swapping the arguments of a function invocation, e.g. in $l _ { 6 }$ of Fig. 2. Rice et al. [26] and DeepBugs [22] tackled this problem when all arguments are single identifiers. PYBUGLAB extends this to swapping arbitrary argument expressions. The rule score function $w _ { \\rho }$ for an argument swapping rewrite is a two-layer MLP applied to the concatenation of the output representations of the representation of the parameter and the to-be-swapped arguments arg1, and arg2: MLP $\\left( [ r _ { \\mathrm { p a r a m s } } , r _ { \\mathrm { a r g 1 } } , r _ { \\mathrm { a r g 2 } } ] \\right)$ . ",
+        "bbox": [
+            173,
+            550,
+            825,
+            635
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Wrong Operator Corrupting operators has a long history in mutation testing [14]. Detecting incorrect operators with deep learning was first tackled by DeepBugs [22] by using learnable embeddings of operators, operands and literals for arithmetic and comparison operators. DeepBugs focused only on binary operators. In PYBUGLAB we tackle all binary operators, including Boolean, arithmetic and comparison operators and two unary operators: logical and arithmetic negation. Locations $l _ { 1 1 }$ , $l _ { 1 4 }$ , $l _ { 1 6 }$ , and $l _ { 2 0 }$ in Fig. 2 are rewrites related to wrong operators. The rule score function $w _ { \\rho }$ for an operator rewrite again uses an inner product, $\\boldsymbol { r } _ { \\ell } ^ { \\top } \\boldsymbol { r } _ { \\mathtt { \\diamond p } }$ , where $\\pmb { r } _ { \\tt o p }$ is a learned embedding for operator op. Note that we rewrite operators only to compatible operators (e.g. $<$ to $>$ but not $^ +$ ). ",
+        "bbox": [
+            173,
+            640,
+            825,
+            752
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Wrong Literal Corrupting operands, and specifically, literals appearing in the source code, is also a common strategy in mutation testing. As in mutation testing, PYBUGLAB handles a limited number of commonly used literals, allowing rewrites to replace integer literals within the set of $- 2 , - 1 , 0 , 1 , 2$ and swapping the Boolean literal True with False and vice versa. The scoring function is identical to the operator rewrite, using a learnable embedding ${ \\bf { r } } _ { \\mathrm { { 1 i t } } }$ for each literal lit. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            828
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 PYBUGLAB Rewrite Rules for Data Augmentation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            843,
+            565,
+            858
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We additionally consider more rewrite rules that are not meant to change the program semantics, using them as a form of data augmentation. This is in spirit similar to ideas in computer vision where images are transformed (e.g. rotated, cropped) but maintain their original content. Such rewrites ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Require: Code dataset $C$ , initial detector/selector model parameters $\\theta ^ { ( 0 ) }$ , $\\phi ^ { ( 0 ) }$ ",
+        "bbox": [
+            173,
+            112,
+            686,
+            127
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1: for meta-epoch $i = 0$ to $I$ do   \n2: // Create dataset of buggy programs:   \n3: $C _ { D } ^ { ( i ) } \\gets \\left\\{ \\left( \\mathrm { s } [ \\rho ] _ { \\ell } , \\left. \\ell , \\rho ^ { - 1 } \\right. \\right) \\mid \\mathrm { s } \\in C , k \\mathrm { \\ s a m p l e s \\ } \\left. \\ell , \\rho \\right. \\sim S _ { \\phi ^ { ( i ) } } ( \\mathrm { s } ) \\right\\}$   \n4: $\\theta ^ { ( i + 1 ) } $ update $\\theta ^ { ( i ) }$ by training $D$ on $C _ { D } ^ { ( i ) }$   \n5: // Create dataset of hard-to-detect bugs:   \n6: $\\begin{array} { r } { C _ { S } ^ { ( i ) } \\gets \\left\\{ \\left( \\mathrm { s } , \\mathrm { a r g } \\operatorname* { m a x } _ { \\langle \\ell , \\rho \\rangle \\in R _ { \\mathrm { s } } ^ { \\mathcal { R } } } \\left( \\mathcal { L } _ { D _ { \\theta ^ { ( i + 1 ) } } } \\left( \\mathrm { s } [ \\rho ] _ { \\ell } , \\langle \\ell , \\rho ^ { - 1 } \\rangle \\right) \\right) \\right) \\mid \\mathrm { s } \\in C \\right\\} } \\end{array}$   \n7: $\\phi ^ { ( i + 1 ) } $ update $\\phi ^ { ( i ) }$ by training $S$ on $C _ { S } ^ { ( i ) }$ ",
+        "bbox": [
+            178,
+            118,
+            686,
+            251
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "have been shown to yield adversarially robust models of code [23]. Although our goal is not to provide adversarial robustness, we believe that such rewrites can help generalization. PYBUGLAB implements the following rewrites for this purpose: ",
+        "bbox": [
+            174,
+            279,
+            825,
+            321
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Variable Renaming renames a local variable to a random name not already in scope. • Comment Deletion removes code comments, including docstrings and inline comments. Such comments commonly contain natural language information that is useful for code comprehension, but usually do not affect program semantics. • Comparison Expression Mirroring swaps the two sides of a comparison operator and changes it appropriately. For example, $\\mathtt { a } < \\mathtt { b }$ is transformed to $\\mathtt { b } > \\mathtt { a }$ . Note that in cases such as $\\mathbf { f } \\circ \\circ ( ) \\ < \\ \\mathsf { b a r } ( )$ , this will change the order of execution of foo and bar, possibly altering program semantics. • If-Else Branch Swapping negates the test condition of an if-else statement or a ternary expressions using DeMorgan’s law and swaps the then body with the else body. ",
+        "bbox": [
+            173,
+            332,
+            828,
+            473
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 Implementation Details ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            494,
+            377,
+            510
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To make the training computationally tractable we approximate Eq. 1. A simplified, sequential version of our training procedure is shown in Alg. 1. Intuitively, we alternate between training the two models, as the (discrete) sampling of rewrite rules in the selector models precludes direct endto-end training. We first use the current state of the selector model to generate “hard” samples and train the detector model on these samples (we always include the unmodified (i.e., NoBug case) as a sample). Then, we use the loss of the detector model to identify those generated samples that were hardest to detect and train the selector model to produce such samples. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            617
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In practice, we implemented the training procedure as a system of asynchronously communi$C _ { D / S } ^ { ( 0 ) } , \\bar { C } _ { D / S } ^ { ( 1 ) } , \\dots$ , and all of the described steps happen in parallel. We do not use “generations”of datasets, but instead use two constantly updated “pools” of training data, one state of the corresponding data pool. We remove samples from the data pool once they have been sampled $\\nu$ times for use in training, in spirit similar to replay buffers in reinforcement learning. In our experiments, $\\nu$ was set to 4. We regularly (in separate, concurrent processes) take snapshots of the the current state of the $D$ and $S$ models to generate new elements that are updated to the data pools, matching the procedure described in Alg. 1. We approximate the arg max in line 6 by only considering the $k$ samples chosen in line 3 for each input program. During training of $S$ , we then mask out the unobserved choices before computing the loss. ",
+        "bbox": [
+            174,
+            623,
+            826,
+            782
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            801,
+            295,
+            819
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now discuss our new dataset and evaluate PYBUGLAB. We $\\divideontimes$ . . . . . . . . . .highlight. . . . .key . . . . . . . .results. ",
+        "bbox": [
+            174,
+            833,
+            738,
+            849
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Datasets To train PYBUGLAB we retrieve the 4k most downloaded packages in the Python package index (PyPI) and take $3 . 4 \\mathrm { k }$ of them as training packages, using the rest for test purposes. During training, PYBUGLAB installs each package along with all its dependencies. Installing all the dependencies is important for extracting the entities and the relations beyond local syntactic ones (e.g. type inference, method resolution). For each file, PYBUGLAB checks if it is a duplicate of a file that has already been seen in the training following the method of Allamanis [1] and runs all the relevant program analyses to extract the entities and relationships in each function. When we use additional rewrites for data augmentation, these are applied at the input of the PYBUGLAB pipeline as a form of pre-processing. Following Alg. 1, the bug selector $S$ selects $k = 5$ bugs to introduce, rewrites the source code text, and then the program analyses extract the new entities and relationships for the rewritten code snippets. The initial and rewritten code snippets are then used to create the training data for the detector and selector models. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            202
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use two testsets to measure performance. First, we create RANDOMBUGS, a testset of 761 445 snippets derived from functions from the $6 0 0 \\mathrm { P y P I }$ test packages (not seen during training). For each function we find within these packages we add it to the dataset along with 9 rewritten functions with a randomly inserted bug. On average graphs have 260 nodes, 601 edges, 25 rewrite locations, and 130 possible rewrites. We also collect a testset of real bugs. Although we conjecture that, in practice, the vast majority of bugs like those discussed in Sec. 4.1 are fixed when developers locally test their software, a few of those slip and then are fixed across different revisions checked into a version control systems. We have crawled the accessible repositories of all $2 8 5 \\mathrm { k }$ packages in the Python Package Index (PyPI), collected and manually filtered bugs captured by the rewrites from Sec. 4.1. $\\divideontimes$ . . . . .This. . . . . .new . . . . . . . . .dataset, . . . . . . . . . . . . . . .PYPIBUGS,. . . . . . . . . .contains. . . . . . .2374 . . . . . . . . . . . . .real-world,. . . . . . .small . . . . . . .bugs. We describe the data collection process in detail in Appx. D. In addition, we consider PYPIBUGS-PostFix: the examples from PYPIBUGS after a bug was fixed - we believe these samples are very likely to not contain any bugs anymore. We publish the dataset at https://www.microsoft.com/en-us/download/103554 and include it in the supplementary material. ",
+        "bbox": [
+            173,
+            208,
+            825,
+            402
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 Quantitative Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            428,
+            380,
+            443
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our first experiment aims to evaluate whether the BUGLAB training framework yields more precise bug detectors. We consider two model architectures, using either GNNs or the GREAT transformer to compute embeddings of code entities (architecture details and hyperparameter choices can be found in Appx. A). We use four different training strategies: “supervised” is training only a bug detector on a fixed dataset of 1 million functions from the $3 . 4 \\mathrm { k }$ training packages with randomly inserted bugs. “Random Selector” refers to a variant of PYBUGLAB using a bug selector model that uniformly at random picks a rewrite to insert bugs. Finally, PYBUGLAB and PYBUGLAB $+ \\mathrm { A u g }$ use our framework from Sec. 2, with the latter also using additional rewrites to augment our code corpus. For the fully supervised model, we train with early stopping over a validation set; the other models are trained for a fixed number of 300 epochs (with $2 0 0 \\mathrm { k }$ training samples per epoch) for the bug detector3 and the last detector model is used for evaluation. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            608
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9a6ef7f5e2c7b5670ec7841f26aeaf6731accd922bc485b255de9a3c978fbd12.jpg",
+        "table_caption": [
+            "Table 1: Accuracies $( \\% )$ for different training strategies and model architectures on RANDOMBUGS. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\"></td><td colspan=\"6\">RANDOMBUGS</td></tr><tr><td></td><td>GNN</td><td></td><td></td><td>GREAT</td><td></td></tr><tr><td>Joint</td><td>Loc</td><td>Repair</td><td>Joint</td><td>Loc</td><td>Repair</td></tr><tr><td>Supervised</td><td>62.4</td><td>73.6</td><td>81.2</td><td>51.0</td><td>61.9</td><td>76.3</td></tr><tr><td>Random Selector</td><td>69.4</td><td>79.6</td><td>84.0</td><td>63.9</td><td>73.6</td><td>82.0</td></tr><tr><td>PYBUGLAB</td><td>69.6</td><td>80.4</td><td>84.2</td><td>64.0</td><td>74.3</td><td>82.3</td></tr><tr><td>PYBUGLAB +Aug</td><td>70.3</td><td>81.1</td><td>84.5</td><td>65.3</td><td>75.3</td><td>82.5</td></tr></table>",
+        "bbox": [
+            433,
+            646,
+            821,
+            751
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Effectiveness of BUGLAB Training We first consider the performance of different models on the synthetic RANDOMBUGS dataset. Tbl. 1 shows the accuracy of predicting a full bug repair correctly (“Joint”) and analogous to Eq. 2 break this up into a localization accuracy (“Loc”) of predicting the correct location (or NoBug for correct examples) and a repair accuracy (“Repair”) for selecting the correct rewrite given the buggy location. ",
+        "bbox": [
+            174,
+            616,
+            419,
+            753
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            179,
+            753,
+            617,
+            767
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We observe that $\\divideontimes$ . . . . . . . . . . . . . . . . . . . . .BUGLAB-training. . . . . . .leads. . . .to . . . . . . .more. . . . . . . .robust. . . . . .bug . . . . . . . . . . .detectors. . . . . . . . . . . . .compared. . .to. . . . . . . .other methods .......... for both GNNs and GREAT. Random selector models — a form of data augmentation — improve performance over supervised methods but mostly on in-distribution RANDOMBUGS samples. As expected, $\\divideontimes$ . . . . . . . . . . . . .augmenting. . . . .the . . . . . .code. . . . . . . . .dataset. . . . . . .helps . . . . . . . . . . . . . . . . .generalization, but does not make a substantial difference. Expanding the kinds of rewrites used to augment the data and learning to select them may improve performance in the future. ",
+        "bbox": [
+            173,
+            773,
+            825,
+            859
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/45931fde220989a07d0269fc66c433e7865bbe57c0647970de9be2941d785c74.jpg",
+        "table_caption": [
+            "Table 2: Results for different training strategies and model architectures on PYPIBUGS. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"6\">PYPIBUGS</td><td colspan=\"4\">PYPIBUGS-PostFix</td></tr><tr><td></td><td colspan=\"3\">GNN</td><td colspan=\"3\">GREAT</td><td colspan=\"2\">GNN</td><td colspan=\"2\">GREAT</td></tr><tr><td></td><td>Joint</td><td>Loc</td><td>Repair</td><td>Joint</td><td>Loc</td><td>Repair</td><td>Loc</td><td>Joint AUC</td><td>Loc</td><td>Joint AUC</td></tr><tr><td>Supervised</td><td>20.0</td><td>28.4</td><td>61.8</td><td>16.8</td><td>25.8</td><td>58.6</td><td>17.8</td><td>0.087</td><td>20.7</td><td>0.044</td></tr><tr><td>Random Selector</td><td>21.2</td><td>27.0</td><td>69.2</td><td>20.6</td><td>26.8</td><td>67.2</td><td>47.5</td><td>0.108</td><td>52.5</td><td>0.117</td></tr><tr><td>PYBUGLAB</td><td>24.2</td><td>31.3</td><td>70.7</td><td>24.0</td><td>32.8</td><td>67.9</td><td>32.9</td><td>0.160</td><td>28.6</td><td>0.140</td></tr><tr><td>PYBUGLAB +Aug</td><td>26.4</td><td>33.5</td><td>72.0</td><td>23.2</td><td>29.7</td><td>68.8</td><td>32.6</td><td>0.187</td><td>48.2</td><td>0.129</td></tr></table>",
+        "bbox": [
+            173,
+            103,
+            820,
+            205
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/bd939f82906d67d424796b5296bcfff95df172b83ccdaf77a3cbb3c270dc7c2c.jpg",
+        "table_caption": [
+            "Table 3: Localization and Repair Accuracy $( \\% )$ per bug kind for the PYBUGLAB +Aug model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\">Bug Type</td><td colspan=\"4\">RANDOMBUGS</td><td colspan=\"4\">PYPIBUGS</td></tr><tr><td colspan=\"2\">GNN</td><td colspan=\"2\">GREAT</td><td colspan=\"2\">GNN</td><td colspan=\"2\">GREAT</td></tr><tr><td>Loc</td><td>Repair</td><td>Loc</td><td>Repair</td><td>Loc</td><td>Repair</td><td>Loc</td><td>Repair</td></tr><tr><td>Argument Swapping</td><td>85.0</td><td>57.3</td><td>65.5</td><td>57.2</td><td>33.2</td><td>73.9</td><td>24.3</td><td>72.7</td></tr><tr><td>Wrong Assign Op</td><td>96.1</td><td>99.1</td><td>94.5</td><td>98.6</td><td>20.0</td><td>68.9</td><td>14.0</td><td>58.1</td></tr><tr><td>Wrong Binary Op</td><td>83.0</td><td>85.2</td><td>77.3</td><td>81.4</td><td>27.2</td><td>54.3</td><td>36.6</td><td>43.7</td></tr><tr><td>Wrong Boolean Op</td><td>71.8</td><td>99.5</td><td>43.6</td><td>99.5</td><td>27.6</td><td>96.9</td><td>15.7</td><td>97.2</td></tr><tr><td>Wrong Comparison Op</td><td>83.9</td><td>79.3</td><td>80.0</td><td>76.4</td><td>33.7</td><td>66.1</td><td>31.1</td><td>53.5</td></tr><tr><td>Wrong Literal</td><td>71.7</td><td>74.7</td><td>66.6</td><td>71.6</td><td>21.6</td><td>78.4</td><td>17.9</td><td>79.5</td></tr><tr><td>Variable Misuse</td><td>84.9</td><td>88.4</td><td>78.2</td><td>86.3</td><td>35.3</td><td>70.5</td><td>34.0</td><td>69.4</td></tr><tr><td>NoBUG</td><td>53.8</td><td></td><td>62.5</td><td></td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            173,
+            234,
+            823,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, $\\ast { \\mathrm { l o u g } } .$ . . . . . . . . . . . . . .localization . . .is . . . . . . .much . . . . . . . .harder. . . . . .than . . . . . . . .repair . . .at . .a . . . . . . .given . . . . . . . . . .location. This is somewhat expected: there are many more candidate locations compared to potential repairs at a given location. However, this suggests that research should focus on the localization problem rather than repair. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            473
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now turn to the results on PYPIBUGS, shown in Tbl. 2, which also includes the accuracy of choosing the special NoBug location on the PYPIBUGS-PostFix dataset, as well as the area under the precision recall curve for the results on both PYPIBUGS and PYPIBUGS-PostFix. ",
+        "bbox": [
+            176,
+            478,
+            821,
+            521
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We find that $\\divideontimes$ . . . . . . . . . .detecting. . . . .and. . . . . . . . . . . .repairing . . . . . . . . .real-life. . . . . . .bugs . .is. . . . . . . . . . . . . . .significantly. . . . . . . .harder. . . . . .than. . . . . . . . . . .handling . . . . . . . . . . . .randomly . . . . . . . . .inserted. . . . . .bugs. As PYBUGLAB models trained using a learned bug selector outperform those using a “Random Selector”, we speculate that the learned selector avoids generating easy-to-detect bugs, focusing the detector model on recognizing deeper semantic patterns. Despite this, improvements in RANDOMBUGS often correlate with improvements in PYPIBUGS. This is encouraging: collecting PYPIBUGS-like datasets is costly; corpora with random bugs can help measure relative improvements to some extent. Finally, we find that $\\divideontimes$ . . . . . . . . . . . . . .recognizing . . . . . . . . . . . . .non-buggy . . . . . . . . . .samples. . .is . . . . . .very . . . . . .hard, and in particular, does not always profit from training in PYBUGLAB. ",
+        "bbox": [
+            173,
+            526,
+            826,
+            641
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In our qualitative analysis (Sec. 5.2), we observed that the models raised some confident but incorrect warnings at very “odd” locations. However, these warnings were different across models. We have tested an ensembling strategy averaging the output probabilities of five separately trained GNN models. This results in localization and repair accuracies of $8 3 . 0 \\%$ and $8 5 . 4 \\%$ on RANDOMBUGS (vs. $8 1 . 1 \\%$ and $8 4 . 5 \\%$ ) and $3 4 . 4 \\%$ and $7 2 . 2 \\%$ on PYPIBUGS (vs. $3 3 . 5 \\%$ and $7 2 . 0 \\%$ ). As we discuss in Sec. 5.2 finding the cause of the “spurious” warnings is important future work. ",
+        "bbox": [
+            174,
+            647,
+            825,
+            731
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Per-Bug Evaluation To better understand which bugs are hard to detect, we break down the results the best-performing PYBUGLAB $+ \\mathrm { A u g }$ models on RANDOMBUGS by type of bug in Tbl. 3. We observe that incorrect literals are some of the hardest bugs to detect. Incorrect assignment operators $( e . g . = \\mathrm { a n d } + = )$ ) are easy to detect in RANDOMBUGS, but significantly harder in PYPIBUGS. This may be attributed to class imbalance, with simple assignment $( = )$ being the majority class. $\\divideontimes$ Detecting . . . . . . . . . . . . . .if .a. . . . . . . . .snippet. . . . .has . .a . . . . .bug . . .or . . . .not. . . . . . . .seems . . .to . . .be. . . .the. . . . . . . . .hardest. . . . . .task:. . . .no. . . . . . . .model . . . . . . . . . .achieves. . . . . . . . . . .accuracy. . . . . . . . .beyond. $6 3 \\%$ . ",
+        "bbox": [
+            173,
+            737,
+            825,
+            824
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We note that in our experiments, GNNs-based models seem to often outperform GREAT, somewhat contradicting the results of Hellendoorn et al. [13]. We have performed substantial additional experiments to investigate and verify these results, cf. Sec. A.2. This may have to do with the performance of these models on long sequences or that the GNN has access to more fine-grained information, instead of relations over the projected token sequences. For example, this could be attributed to the lack of syntax and symbol nodes in the representation used in GREAT. Nevertheless, GREAT is noticeably better ( $6 2 . 5 \\%$ vs. $5 3 . 8 \\%$ ) at detecting NoBug and locating wrong binary operators in PYPIBUGS. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/8037918e569bcf21bec36b8e0c64c703d98d376bc99408953d5a9a1d383a3d17.jpg",
+        "table_caption": [
+            "Table 5: Bug distribution $( \\% )$ in different datasets "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Bug Kind</td><td>PYPIBUGS</td><td>RANDOMBUGS</td><td>Selector Samples</td></tr><tr><td>Argument Swapping</td><td>11.9</td><td>8.4</td><td>23.8</td></tr><tr><td>Wrong Assignment</td><td>1.9</td><td>8.5</td><td>5.3</td></tr><tr><td>Wrong Binary Operator</td><td>3.4</td><td>2.4</td><td>2.3</td></tr><tr><td>Wrong Boolean Operator</td><td>8.1</td><td>2.2</td><td>6.4</td></tr><tr><td>Wrong Comparison Operator</td><td>17.1</td><td>8.2</td><td>7.4</td></tr><tr><td>Wrong Literal</td><td>3.7</td><td>11.6</td><td>12.4</td></tr><tr><td>Variable Misuse</td><td>53.8</td><td>58.6</td><td>42.5</td></tr></table>",
+        "bbox": [
+            215,
+            103,
+            782,
+            229
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            272,
+            823,
+            300
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Bug Selector Performance To understand how training of the bug selector proceeds, we perform two experiments. In our first experiment, we take a snapshot of the selector model during training of the PYBUGLAB $+ \\mathrm { A u g }$ (GNN) model every 24 hours, after an initial burn-in phase of 12 hours. We then generate 10000 buggy samples using each of these snapshots and then test a fixed model on each of these snapshots. The results of this are shown in Tbl. 4, using a fully trained PYBUGLAB $+ \\mathrm { A u g }$ (GNN) model from another training run as a fixed model. We conclude that . . . . . . . . . . . . . . . . . . . . . . . . .PYBUGLAB succeeds. . . .in . . . . . . . . . .learning . . .to . . . . . . . . . .generate. . . . . . . .harder. . .to find ..........bugs, though we can observe the selector model trading off “harder-to-localize” and “harder-tofix” properties. Tests on other models show similar trends, confirming the robustness of this result. ",
+        "bbox": [
+            174,
+            306,
+            549,
+            460
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            462,
+            825,
+            488
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/c3149cb1f9f5d33fffe426f0377edd65043e8b7a01d9e6d5a8af81a8671b2daa.jpg",
+        "table_caption": [
+            "Table 4: Development of Performance on Bug Selector Samples "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Training&#x27; Time</td><td>Joint</td><td>Loc</td><td>Repair</td></tr><tr><td>0.5 days</td><td>64.2</td><td>83.8</td><td>72.1</td></tr><tr><td>1.5 days</td><td>62.5</td><td>80.7</td><td>72.9</td></tr><tr><td>2.5 days</td><td>62.0</td><td>83.0</td><td>69.8</td></tr><tr><td>3.5 days</td><td>61.7</td><td>82.5</td><td>69.8</td></tr><tr><td>4.5 days</td><td>61.9</td><td>83.0</td><td>69.5</td></tr><tr><td>5.5 days</td><td>61.1</td><td>83.0</td><td>68.6</td></tr><tr><td>6.5 days</td><td>60.5</td><td>78.7</td><td>72.4</td></tr></table>",
+        "bbox": [
+            560,
+            332,
+            823,
+            459
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In a second experiment, we compare the distribution of different bug kinds in PYPIBUGS and RANDOMBUGS with the distribution of bugs sampled from the final snapshot of our selector model from above. The results are shown in Tbl. 5, where we can see that a number of bugs (argument swapping, use of wrong literals and of assignment operators) are substantially over-represented, whereas mistakes in comparison operators and variable misuse are under-represented. This indicates that . . . . . . . . . . . . . . . . . . . . . . . . . .PYBUGLAB generates. . . . . .hard . . .to . . . . . .find, . . . .but. . . .not. . . . . . . . . . . . . .necessarily . . . . . . . . . .realistic . . . . . .bugs. ",
+        "bbox": [
+            174,
+            494,
+            826,
+            579
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparison to CuBERT Finally, we compare our models to CuBERT [15], which uses a masked language modeling objective to pre-train a BERT-like model and then learns bug detectors specific to a class of bugs (e.g., wrong binary operators) on top of this pre-trained model. Note that CuBERT detects $i f$ a bug exists but does not localize it. For the comparison, we create two sub-datasets of PYPIBUGS: PYPIBUGS-WrongOp contains the 501 samples that involve the binary operators supported by CuBERT, and PYPIBUGS-VarMisuse, which contains the 1278 bugs that involve variable misuses. We complete both of these datasets with 501 (resp. 1278) random NoBug code samples from our RANDOMBUGS, to match the 1:1 buggy/non-buggy distribution used in CuBERT’s training. Since CuBERT classification models focus on a single bug type, to compare to PYBUGLAB we mask out all code locations that do not correspond to a bug that could be detected by the corresponding CuBERT model. We then treat the prediction of the NoBug location as a “non-buggy” prediction and all other locations as a “buggy” prediction. For example, for the snippet in Fig. 2, only the locations $l _ { 2 }$ , $l _ { 1 1 }$ , $l _ { 1 4 }$ , $l _ { 1 6 }$ , and $l _ { 2 0 }$ and their corresponding rewrites are considered by PYBUGLAB for the comparison on PYPIBUGS-WrongOp. ",
+        "bbox": [
+            173,
+            585,
+            826,
+            779
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Tbl. 6 shows the results of comparing the released CuBERT snapshots with the PYBUGLAB +Aug GNN model. We observe that $\\divideontimes$ . . . .the . . . . . . . . . . . . . . . . . . . . . . . . .PYBUGLAB models ",
+        "bbox": [
+            173,
+            785,
+            356,
+            871
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/55b3364d400dfb104c428ee8540f8da946936e41c3e3c9c9a4e40abf08959203.jpg",
+        "table_caption": [
+            "Table 6: Comparison with CuBERT [15] "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"3\">CuBERT</td><td colspan=\"3\">PYBUGLAB (GNN)</td></tr><tr><td>Prec</td><td>Recall</td><td>F1</td><td>Prec</td><td>Recall</td><td>F1</td></tr><tr><td>PYPIBUGs-WrongOp</td><td>0.764</td><td>0.251</td><td>0.378</td><td>0.730</td><td>0.764</td><td>0.746</td></tr><tr><td>PYPIBUGS-VarMisuse</td><td>0.632</td><td>0.403</td><td>0.493</td><td>0.740</td><td>0.840</td><td>0.787</td></tr></table>",
+        "bbox": [
+            364,
+            796,
+            823,
+            864
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": ". . . . .have. . . . . . . . . . . . . . . .substantially . . . . . . .better. . . . . . .recall. . . . . .than. . . . . . . . . . . . . . . . . . .CuBERT-based . . . . . . . . .models, even though they were trained to detect more bug types. When calibrating the CuBERT models to have a recall equal to PYBUGLAB, heir precision drops substantially. In particular, on PYPIBUGS-WrongOp, it is reduced to 0.609, and ",
+        "bbox": [
+            181,
+            869,
+            826,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "1 def make_id(name):   \n2 $\\mathbf { r } \\ =$ get_rand_string(12)   \n3 if len(name) <= 22:   \n4 name $=$ name[:22]   \n5 return name $\\textrm { + } \\textrm { -- } \\textrm { + } \\textrm { \\pmb { r } }$ (a) A wrong comparison operator bug (red box) in PYPIBUGS detected and repaired by the GNN PYBUGLAB +Aug models. ",
+        "bbox": [
+            163,
+            108,
+            468,
+            213
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "1 def update(self, roomId,   \n2 title, \\*\\*request_params):   \n3 check_type(roomId, basestring)   \n4 check_type(roomId, basestring)   \n5 [...] ",
+        "bbox": [
+            486,
+            97,
+            774,
+            160
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(b) A variable misuse (red box) caught in an open-source project. GNN PYBUGLAB $+ \\mathrm { A u g }$ suggests to rewrite roomId to title. The fixing pull request is found here. ",
+        "bbox": [
+            496,
+            174,
+            825,
+            213
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 3: Bugs found by PYBUGLAB. Snippets reformatted and abbreviated to fit figure. ",
+        "bbox": [
+            207,
+            220,
+            789,
+            236
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "on PYPIBUGS-VarMisuse, it is reduced to 0.613; in both cases, PYBUGLAB outperforms CuBERT substantially. ",
+        "bbox": [
+            173,
+            277,
+            825,
+            306
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 Qualitative Inspection of Raised Warnings ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            338,
+            508,
+            354
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We now take a qualitative look at the raised warnings raised by PYBUGLAB. As example, Fig. 3a shows a sample of PYPIBUGS where the developer used an incorrect comparison operator. Once pointed to it, it is clear to a human that the truncation statement in line 4 has no effect (under the reasonable assumption that name is a string), and that a different comparison operator $( > )$ is necessary. ",
+        "bbox": [
+            174,
+            372,
+            825,
+            428
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To gain an understanding of the performance of PYBUGLAB on realistic data, we performed an indepth analysis of the cases flagged as bugs by our best-performing model on the code found within the 4k top PyPI packages. We observed a mixture of false positives with few previously unseen real-life bugs, matching the quantitative results in Tbl. 3. First, we find that the majority of the false positives are “incorrect literal” detections. This suggests that learning to detect such bugs is a hard problem. Furthermore, many literals serve as default “configurations” (e.g. the number of retries for a network request) and different values are not bugs. We posit that a large percentage of literal replacements the selector learns to make fall in this category. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            545
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We also found that some repairs suggested by the model actually produce semantically equivalent code. For example, the model lacks knowledge that two variables refer to the same object in memory (aliasing), and so attempts to “repair” variable misuse bugs by switching between these. Other examples includes checking the return values of standard functions such as Python’s str.find, which returns $^ { - 1 }$ if the query string is not found. In such cases, PYBUGLAB often suggested to rewrite an if $\\mathbf { x } \\lrcorner \\mathbf { f i n d } ( \\mathbf { y } ) \\ \\ll \\ - 1$ to if $\\mathbf { x } \\lrcorner \\mathbf { f i n d } ( \\mathbf { y } ) \\ = - 1$ , which makes no difference in practice. These false negatives can be attributed to the fact that the bug selector model considers such changes as introducing bugs, even though they are not actually changing behavior. This suggests that for better results, the rewrite rules need to ensure that the rewrites are not semantics-preserving and represent bugs. ",
+        "bbox": [
+            173,
+            551,
+            825,
+            689
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, some reported issues were sufficiently complex that it took us (the human authors) a couple of minutes of thought to conclude that a warning is spurious. Simultaneously, there are some warnings that are “obviously” incorrect to us, but the reasons why the neural models raise them is unclear. This highlights the importance of research on explainability techniques along with better ways to calibrate model confidence. The fact that selectors may introduce spurious “bugs” may also be affecting how the detector model learns. Ideas that have appeared in reinforcement learning, such as the one of Dennis et al. [8], may allow models to improve their performance in spite of spurious bugs. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            792
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Overall, $\\yen 123,456,7$ . . .of. . . . .the . . . . . .1000. . . . . . . . . . .reported . . . . . . . . . . .warnings . . . . . .were. . . . . . . .found . . .to . . .be. . . . . . . . . .real-life. . . . . . .bugs. Of these 19, we reported 11 on GitHub (6 already merged, 5 pending approval). See Appx. G for details. 3 other bugs had already been fixed between the version PYBUGLAB processed and the current version or the project was deprecated, whereas another 5 bugs are minor and we decided not to report them. One of the detected bugs is shown in Fig. 3b. Overall, most of the detected bugs appear within unit tests, logging, or exception handling, possibly because bugs there do not impact the core functionality of a project. However, given the number of such bugs we collected in PYPIBUGS, we believe that such bugs arise equally often in other code, but that they are detected and fixed more quickly. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Although our analysis only forms a lower bound on the precision of PYBUGLAB and related methods, it suggests that there is still ample room for future improvements towards making machine learningbased bug detection and repair practically useful. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            152,
+            321,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Detecting bugs in source code has been researched since the early days of computing. Traditionally, bug detection is tackled as a formal task, where any code that cannot be proved to satisfy some correctness property may contain a bug. This is essential for security- and safety-critical bugs, but not for other — equally common — bugs. In the last decade, software engineering and programming language research have increasingly realized ambiguous information within code (e.g. variable names, comments) contains valuable information and using this information can yield valuable results [2]. The main premise is that patterns in source code, such as patterns in names, control, and data flow can be informative. This information can also be exploited to detect some bugs. For example, Ray et al. [24] noted that even simple language models tend to assign lower probability to buggy code. ",
+        "bbox": [
+            174,
+            185,
+            825,
+            310
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Multiple static analysis methods have been researched that combine some form of data-oriented bug detection. This ranges from language model-based tools, such as the early work of Wang et al. [32] to specification-mining tools such as the work of Eberhardt et al. [10]. BUGLAB is related to DeepBugs [22] which uses an MLP over a limited window of code tokens and train separate models to detect wrong operators, operands, and argument swappings. BUGLAB opts for a more structured representation of code and a single model. Allamanis et al. [3], Vasic et al. [30], Hellendoorn et al. [13] tackle variable misuse bugs (one of the kinds of bugs included in PYBUGLAB) but either by randomly introducing the bugs in code or using a Cloze-like test. Instead, BUGLAB opts for a selfsupervised approach and tackles a broader range of bugs. Concurrently to this work, Patra and Pradel [21] showed an alternative method for learning to generate realistic bugs. Dinella et al. [9] learn a supervised sequential model that performs graph transformations that replicate small edits in code (refactoring, introducing functionality, bug fixing, etc.). Their model — Hoppity — could serve as a learnable rewrite operation in BUGLAB in future work. Dynamic analysis methods have also been researched with promising results [31], but collecting representative dynamic traces over a diverse set of programs at scale (e.g. from the top Python packages used in this work) is practically impossible. ",
+        "bbox": [
+            174,
+            316,
+            826,
+            523
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "BUGLAB is related to ideas around self-supervised learning recently explored in deep learning, computer vision, and NLP. In our case, we aim to train a bug detection model without using training data from real-life bugs. BUGLAB resembles ELECTRA [6], with the important difference that the rewrites to the input code go beyond single token replacement that need to respect strict constraints of programming languages (syntax, variable scopes) and the model is directly used for bug detection, rather than for pre-training. The main BUGLAB objective Eq. 1 also resembles GANs [12] with the exception that the objective is non-differentiable (introducing a bug alters the discrete data representation), the selector is a structured probabilistic code rewriting model, and that we are mainly interested in the bug detector (analogous to the discriminator) rather than the selector. ",
+        "bbox": [
+            174,
+            529,
+            825,
+            655
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Discussion and Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            674,
+            434,
+            691
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Learned program analyses offer the promise to improve how we develop software. They also offer a great opportunity to study machine learning models that combine formal and probabilistic reasoning. Towards achieving these we presented BUGLAB, a self-supervised approach for learning program analyses, that improves upon baseline methods and detects bugs in real-life code. We also empirically show the limitations of existing bug-detecting machine learning methods, which suffer from impractical false-positive rates. Importantly, we show the large gap of performance of existing methods on corpora of randomly inserted bugs — commonly used in prior work — and real-life bugs. ",
+        "bbox": [
+            174,
+            705,
+            826,
+            804
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            824,
+            338,
+            840
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We want to thank Sebastian Nowozin and Marwin Segler for helpful discussions, Marwin Segler for comments on a draft of this work, and the anonymous reviewers for useful questions and suggestions. Finally, we would like to thank the contributors to the following open-source tools used: PyTorch [20], PyDriller [27], MessagePack, LibCST, Jedi, Kubernetes, Helm. ",
+        "bbox": [
+            176,
+            856,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] M. Allamanis. The adverse effects of code duplication in machine learning models of code. In Proceedings of the 2019 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software, pages 143–153, 2019.   \n[2] M. Allamanis, E. T. Barr, P. Devanbu, and C. Sutton. A survey of machine learning for big code and naturalness. ACM Computing Surveys (CSUR), 51(4):1–37, 2018.   \n[3] M. Allamanis, M. Brockschmidt, and M. Khademi. Learning to represent programs with graphs. In International Conference on Learning Representations (ICLR), 2018.   \n[4] M. Allamanis, E. Barr, S. Ducousso, and Z. Gao. Typilus: Neural type hints. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), pages 91–105. Association for Computing Machinery (ACM), 2020.   \n[5] T. Bachlechner, B. P. Majumder, H. H. Mao, G. W. Cottrell, and J. McAuley. Rezero is all you need: Fast convergence at large depth. arXiv preprint arXiv:2003.04887, 2020.   \n[6] K. Clark, M.-T. Luong, Q. V. Le, and C. D. Manning. ELECTRA: Pre-training text encoders as discriminators rather than generators. arXiv preprint arXiv:2003.10555, 2020.   \n[7] M. Cvitkovic, B. Singh, and A. Anandkumar. Deep learning on code with an unbounded vocabulary. In Machine Learning 4 Programming, 2018.   \n[8] M. Dennis, N. Jaques, E. Vinitsky, A. Bayen, S. Russell, A. Critch, and S. Levine. Emergent complexity and zero-shot transfer via unsupervised environment design. arXiv preprint arXiv:2012.02096, 2020.   \n[9] E. Dinella, H. Dai, Z. Li, M. Naik, L. Song, and K. Wang. Hoppity: Learning graph transformations to detect and fix bugs in programs. In International Conference on Learning Representations, 2019.   \n[10] J. Eberhardt, S. Steffen, V. Raychev, and M. Vechev. Unsupervised learning of API aliasing specifications. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation, pages 745–759, 2019.   \n[11] J. Gilmer, S. S. Schoenholz, P. F. Riley, O. Vinyals, and G. E. Dahl. Neural message passing for quantum chemistry. In International Conference on Machine Learning, pages 1263–1272, 2017.   \n[12] I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial networks. arXiv preprint arXiv:1406.2661, 2014.   \n[13] V. J. Hellendoorn, C. Sutton, R. Singh, P. Maniatis, and D. Bieber. Global relational models of source code. In International Conference on Learning Representations, 2020.   \n[14] R. Just, D. Jalali, L. Inozemtseva, M. D. Ernst, R. Holmes, and G. Fraser. Are mutants a valid substitute for real faults in software testing? In Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering, pages 654–665, 2014.   \n[15] A. Kanade, P. Maniatis, G. Balakrishnan, and K. Shi. Learning and evaluating contextual embedding of source code. In International Conference on Machine Learning (ICML), 2020.   \n[16] R.-M. Karampatsis and C. Sutton. How often do single-statement bugs occur? the ManySStuBs4J dataset. In Proceedings of the 17th International Conference on Mining Software Repositories, pages 573–577, 2020.   \n[17] J. Katz. Libraries.io Open Source Repository and Dependency Metadata, Jan. 2020. URL https://doi.org/10.5281/zenodo.3626071.   \n[18] Y. Li, D. Tarlow, M. Brockschmidt, and R. Zemel. Gated graph sequence neural networks. In International Conference on Learning Representations (ICLR), 2016. ",
+        "bbox": [
+            171,
+            87,
+            830,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[19] S. Merity, C. Xiong, J. Bradbury, and R. Socher. Pointer sentinel mixture models. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            171,
+            90,
+            826,
+            121
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[20] A. Paszke, S. Gross, S. Chintala, G. Chanan, E. Yang, Z. DeVito, Z. Lin, A. Desmaison, L. Antiga, and A. Lerer. Automatic differentiation in PyTorch. 2017.   \n[21] J. Patra and M. Pradel. Semantic bug seeding: a learning-based approach for creating realistic bugs. In Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, pages 906–918, 2021.   \n[22] M. Pradel and K. Sen. DeepBugs: A learning approach to name-based bug detection. Proceedings of the ACM on Programming Languages, 2(OOPSLA):1–25, 2018.   \n[23] G. Ramakrishnan, J. Henkel, Z. Wang, A. Albarghouthi, S. Jha, and T. Reps. Semantic robustness of models of source code. arXiv preprint arXiv:2002.03043, 2020.   \n[24] B. Ray, V. Hellendoorn, S. Godhane, Z. Tu, A. Bacchelli, and P. Devanbu. On the ”naturalness” of buggy code. In 2016 IEEE/ACM 38th International Conference on Software Engineering (ICSE), pages 428–439. IEEE, 2016.   \n[25] V. Raychev, M. Vechev, and A. Krause. Predicting program properties from Big Code. In Principles of Programming Languages (POPL), 2015.   \n[26] A. Rice, E. Aftandilian, C. Jaspan, E. Johnston, M. Pradel, and Y. Arroyo-Paredes. Detecting argument selection defects. Proceedings of the ACM on Programming Languages, 1(OOPSLA): 1–22, 2017.   \n[27] D. Spadini, M. Aniche, and A. Bacchelli. PyDriller: Python framework for mining software repositories. In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering - ESEC/FSE 2018, pages 908–911, New York, New York, USA, 2018. ACM Press. ISBN 9781450355735. doi: 10.1145/3236024.3264598. URL http://dl.acm.org/citation. cfm?doid $\\equiv$ 3236024.3264598.   \n[28] D. Tarlow, S. Moitra, A. Rice, Z. Chen, P.-A. Manzagol, C. Sutton, and E. Aftandilian. Learning to fix build errors with Graph2Diff neural networks. In Proceedings of the IEEE/ACM 42nd International Conference on Software Engineering Workshops, pages 19–20, 2020.   \n[29] H. Touvron, M. Cord, A. Sablayrolles, G. Synnaeve, and H. Jegou. Going deeper with image ´ transformers. arXiv preprint arXiv:2103.17239, 2021.   \n[30] M. Vasic, A. Kanade, P. Maniatis, D. Bieber, and R. Singh. Neural program repair by jointly learning to localize and repair. arXiv preprint arXiv:1904.01720, 2019.   \n[31] K. Wang and Z. Su. Blended, precise semantic program embeddings. In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation, pages 121–134, 2020.   \n[32] S. Wang, D. Chollak, D. Movshovitz-Attias, and L. Tan. Bugram: bug detection with n-gram language models. In Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering, pages 708–719, 2016.   \n[33] J. Wei, M. Goyal, G. Durrett, and I. Dillig. LambdaNet: Probabilistic type inference using graph neural networks. arXiv preprint arXiv:2005.02161, 2020. ",
+        "bbox": [
+            169,
+            98,
+            828,
+            785
+        ],
+        "page_idx": 11
+    }
+]