Add files using upload-large-folder tool

parse/train/HkE0Nvqlg/HkE0Nvqlg.md

@@ -0,0 +1,572 @@
+# STRUCTURED ATTENTION NETWORKS
+
+Yoon $\mathbf { K i m } ^ { * }$ Carl Denton∗ Luong Hoang Alexander M. Rush
+
+{yoonkim@seas,carldenton@college,lhoang@g,srush@seas}.harvard.edu   
+School of Engineering and Applied Sciences   
+Harvard University   
+Cambridge, MA 02138, USA
+
+# ABSTRACT
+
+Attention networks have proven to be an effective approach for embedding categorical inference within a deep neural network. However, for many tasks we may want to model richer structural dependencies without abandoning end-to-end training. In this work, we experiment with incorporating richer structural distributions, encoded using graphical models, within deep networks. We show that these structured attention networks are simple extensions of the basic attention procedure, and that they allow for extending attention beyond the standard softselection approach, such as attending to partial segmentations or to subtrees. We experiment with two different classes of structured attention networks: a linearchain conditional random field and a graph-based parsing model, and describe how these models can be practically implemented as neural network layers. Experiments show that this approach is effective for incorporating structural biases, and structured attention networks outperform baseline attention models on a variety of synthetic and real tasks: tree transduction, neural machine translation, question answering, and natural language inference. We further find that models trained in this way learn interesting unsupervised hidden representations that generalize simple attention.
+
+# 1 INTRODUCTION
+
+Attention networks are now a standard part of the deep learning toolkit, contributing to impressive results in neural machine translation (Bahdanau et al., 2015; Luong et al., 2015), image captioning (Xu et al., 2015), speech recognition (Chorowski et al., 2015; Chan et al., 2015), question answering (Hermann et al., 2015; Sukhbaatar et al., 2015), and algorithm-learning (Graves et al., 2014; Vinyals et al., 2015), among many other applications (see Cho et al. (2015) for a comprehensive review). This approach alleviates the bottleneck of compressing a source into a fixed-dimensional vector by equipping a model with variable-length memory (Weston et al., 2014; Graves et al., 2014; 2016), thereby providing random access into the source as needed. Attention is implemented as a hidden layer which computes a categorical distribution (or hierarchy of categorical distributions) to make a soft-selection over source elements.
+
+Noting the empirical effectiveness of attention networks, we also observe that the standard attentionbased architecture does not directly model any structural dependencies that may exist among the source elements, and instead relies completely on the hidden layers of the network. While one might argue that these structural dependencies can be learned implicitly by a deep model with enough data, in practice, it may be useful to provide a structural bias. Modeling structural dependencies at the final, output layer has been shown to be important in many deep learning applications, most notably in seminal work on graph transformers (LeCun et al., 1998), key work on NLP (Collobert et al., 2011), and in many other areas (Peng et al., 2009; Do & Artieres, 2010; Jaderberg et al., 2014; Chen ´ et al., 2015; Durrett & Klein, 2015; Lample et al., 2016, inter alia).
+
+In this work, we consider applications which may require structural dependencies at the attention layer, and develop internal structured layers for modeling these directly. This approach generalizes categorical soft-selection attention layers by specifying possible structural dependencies in a soft manner. Key applications will be the development of an attention function that segments the source input into subsequences and one that takes into account the latent recursive structure (i.e. parse tree) of a source sentence.
+
+Our approach views the attention mechanism as a graphical model over a set of latent variables. The standard attention network can be seen as an expectation of an annotation function with respect to a single latent variable whose categorical distribution is parameterized to be a function of the source. In the general case we can specify a graphical model over multiple latent variables whose edges encode the desired structure. Computing forward attention requires performing inference to obtain the expectation of the annotation function, i.e. the context vector. This expectation is computed over an exponentially-sized set of structures (through the machinery of graphical models/structured prediction), hence the name structured attention network. Notably each step of this process (including inference) is differentiable, so the model can be trained end-to-end without having to resort to deep policy gradient methods (Schulman et al., 2015).
+
+The differentiability of inference algorithms over graphical models has previously been noted by various researchers (Li & Eisner, 2009; Domke, 2011; Stoyanov et al., 2011; Stoyanov & Eisner, 2012; Gormley et al., 2015), primarily outside the area of deep learning. For example, Gormley et al. (2015) treat an entire graphical model as a differentiable circuit and backpropagate risk through variational inference (loopy belief propagation) for minimium risk training of dependency parsers. Our contribution is to combine these ideas to produce structured internal attention layers within deep networks, noting that these approaches allow us to use the resulting marginals to create new features, as long as we do so a differentiable way.
+
+We focus on two classes of structured attention: linear-chain conditional random fields (CRFs) (Lafferty et al., 2001) and first-order graph-based dependency parsers (Eisner, 1996). The initial work of Bahdanau et al. (2015) was particularly interesting in the context of machine translation, as the model was able to implicitly learn an alignment model as a hidden layer, effectively embedding inference into a neural network. In similar vein, under our framework the model has the capacity to learn a segmenter as a hidden layer or a parser as a hidden layer, without ever having to see a segmented sentence or a parse tree. Our experiments apply this approach to a difficult synthetic reordering task, as well as to machine translation, question answering, and natural language inference. We find that models trained with structured attention outperform standard attention models. Analysis of learned representations further reveal that interesting structures emerge as an internal layer of the model. All code is available at http://github.com/harvardnlp/struct-attn.
+
+# 2 BACKGROUND: ATTENTION NETWORKS
+
+A standard neural network consist of a series of non-linear transformation layers, where each layer produces a fixed-dimensional hidden representation. For tasks with large input spaces, this paradigm makes it hard to control the interaction between components. For example in machine translation, the source consists of an entire sentence, and the output is a prediction for each word in the translated sentence. Utilizing a standard network leads to an information bottleneck, where one hidden layer must encode the entire source sentence. Attention provides an alternative approach.1 An attention network maintains a set of hidden representations that scale with the size of the source. The model uses an internal inference step to perform a soft-selection over these representations. This method allows the model to maintain a variable-length memory and has shown to be crucially important for scaling systems for many tasks.
+
+Formally, let $\boldsymbol { x } ~ = ~ [ x _ { 1 } , \dots , x _ { n } ]$ represent a sequence of inputs, let $q$ be a query, and let $z$ be a categorical latent variable with sample space $\{ 1 , \ldots , n \}$ that encodes the desired selection among these inputs. Our aim is to produce a context $c$ based on the sequence and the query. To do so, we assume access to an attention distribution $z \sim p ( z \mid x , q )$ , where we condition $p$ on the inputs $x$ and a query $q$ . The context over a sequence is defined as expectation, $c = \mathbb { E } _ { z \sim p ( z \mid x , q ) } [ f ( x , z ) ]$ where $f ( x , z )$ is an annotation function. Attention of this form can be applied over any type of input, however, we will primarily be concerned with “deep” networks, where both the annotation function and attention distribution are parameterized with neural networks, and the context produced is a vector fed to a downstream network.
+
+For example, consider the case of attention-based neural machine translation (Bahdanau et al., 2015). Here the sequence of inputs $\left[ \mathbf { x } _ { 1 } , \ldots , \mathbf { x } _ { n } \right]$ are the hidden states of a recurrent neural network (RNN), running over the words in the source sentence, $\mathbf { q }$ is the RNN hidden state of the target decoder (i.e. vector representation of the query $q$ ), and $z$ represents the source position to be attended to for translation. The attention distribution $p$ is simply $p ( z = i \mid x , q ) = \operatorname { s o f t m a x } ( \theta _ { i } )$ where $\boldsymbol \theta \in \mathbb { R } ^ { n }$ is a parameterized potential typically based on a neural network, e.g. $\theta _ { i } = \mathrm { M L P } ( [ \mathbf { x } _ { i } ; \mathbf { q } ] )$ . The annotation function is defined to simply return the selected hidden state, $f ( \mathbf { x } , z ) = \mathbf { x } _ { z }$ . The context vector can then be computed using a simple sum,
+
+$$
+\mathbf { c } = \mathbb { E } _ { z \sim p ( z \mid x , q ) } [ f ( x , z ) ] = \sum _ { i = 1 } ^ { n } p ( z = i \mid x , q ) \mathbf { x } _ { i }
+$$
+
+Other tasks such as question answering use attention in a similar manner, for instance by replacing source $[ x _ { 1 } , \ldots , x _ { n } ]$ with a set of potential facts and $q$ with a representation of the question.
+
+In summary we interpret the attention mechanism as taking the expectation of an annotation function $f ( x , z )$ with respect to a latent variable $z \sim p$ , where $p$ is parameterized to be function of $x$ and $q$ .
+
+# 3 STRUCTURED ATTENTION
+
+Attention networks simulate selection from a set using a soft model. In this work we consider generalizing selection to types of attention, such as selecting chunks, segmenting inputs, or even attending to latent subtrees. One interpretation of this attention is as using soft-selection that considers all possible structures over the input, of which there may be exponentially many possibilities. Of course, this expectation can no longer be computed using a simple sum, and we need to incorporate the machinery of inference directly into our neural network.
+
+Define a structured attention model as being an attention model where $z$ is now a vector of discrete latent variables $[ z _ { 1 } , \ldots , z _ { m } ]$ and the attention distribution is $p ( z \mid x , q )$ is defined as a conditional random field (CRF), specifying the independence structure of the $z$ variables. Formally, we assume an undirected graph structure with $m$ vertices. The CRF is parameterized with clique (log-)potentials $\theta _ { C } ( z _ { C } ) \in \mathbb { R }$ , where the $z _ { C }$ indicates the subset of $z$ given by clique $C$ . Under this definition, the attention probability is defined as, $p ( z \mid x , q ; \theta ) = \mathrm { s o f t m a x } ( \sum _ { C } \theta _ { C } ( z _ { C } ) )$ , where for symmetry we use softmax in a general sense, i.e. $\begin{array} { r } { \mathrm { s o f t m a x } ( g ( z ) ) = \frac { 1 } { Z } \exp ( g ( z ) ) } \end{array}$ where $\begin{array} { r } { Z = \sum _ { z ^ { \prime } } \exp ( g ( z ^ { \prime } ) ) } \end{array}$ is the implied partition function. In practice we use a neural CRF, where $\theta$ comes from a deep model over $x , q$ .
+
+In structured attention, we also assume that the annotation function $f$ factors (at least) into clique annotation functions $\begin{array} { r } { f ( x , z ) = \sum _ { C } f _ { C } ( x , z _ { C } ) } \end{array}$ . Under standard conditions on the conditional independence structure, inference techniques from graphical models can be used to compute the forwardpass expectations and the context:
+
+$$
+c = \mathbb { E } _ { z \sim p ( z \mid x , q ) } [ f ( x , z ) ] = \sum _ { C } \mathbb { E } _ { z \sim p ( z _ { C } \mid x , q ) } [ f _ { C } ( x , z _ { C } ) ]
+$$
+
+# 3.1 EXAMPLE 1: SUBSEQUENCE SELECTION
+
+Suppose instead of soft-selecting a single input, we wanted to explicitly model the selection of contiguous subsequences. We could naively apply categorical attention over all subsequences, or hope the model learns a multi-modal distribution to combine neighboring words. Structured attention provides an alternate approach.
+
+Concretely, let $m = n$ , define $z$ to be a random vector $z = [ z _ { 1 } , \dots , z _ { n } ]$ with $z _ { i } \in \{ 0 , 1 \}$ , and define our annotation function to be, $\begin{array} { r } { f ( x , z ) = \sum _ { i = 1 } ^ { n } f _ { i } ( x , z _ { i } ) } \end{array}$ where $f _ { i } ( x , z _ { i } ) = \mathbb { 1 } \{ z _ { i } = 1 \} \mathbf { x } _ { i }$ . The explicit expectation is then,
+
+$$
+\mathbb { E } _ { z _ { 1 } , \dots , z _ { n } } [ f ( x , z ) ] = \sum _ { i = 1 } ^ { n } p ( z _ { i } = 1 | x , q ) \mathbf { x } _ { i }
+$$
+
+![](images/1eba9c365722e0dbeb50c39e623c13011565796f4b607ac782d0965fe4013f8b.jpg)  
+Figure 1: Three versions of a latent variable attention model: (a) A standard soft-selection attention network, (b) A Bernoulli (sigmoid) attention network, (c) A linear-chain structured attention model for segmentation. The input and query are denoted with $x$ and $q$ respectively.
+
+Equation (2) is similar to equation (1)—both are a linear combination of the input representations where the scalar is between $[ 0 , 1 ]$ and represents how much attention should be focused on each input. However, (2) is fundamentally different in two ways: (i) it allows for multiple inputs (or no inputs) to be selected for a given query; (ii) we can incorporate structural dependencies across the $z _ { i }$ ’s. For instance, we can model the distribution over $z$ with a linear-chain CRF with pairwise edges,
+
+$$
+p ( z _ { 1 } , \dots , z _ { n } | x , q ) = \mathrm { s o f t m a x } \left( \sum _ { i = 1 } ^ { n - 1 } \theta _ { i , i + 1 } ( z _ { i } , z _ { i + 1 } ) \right)
+$$
+
+where $\theta _ { k , l }$ is the pairwise potential for $z _ { i } = k$ and $z _ { i + 1 } = l$ . This model is shown in Figure 1c. Compare this model to the standard attention in Figure 1a, or to a simple Bernoulli (sigmoid) selection method, $p ( z _ { i } = 1 | x , q ) = \mathrm { s i g m o i d } ( \theta _ { i } )$ , shown in Figure 1b. All three of these methods can use potentials from the same neural network or RNN that takes $x$ and $q$ as inputs.
+
+In the case of the linear-chain CRF in (3), the marginal distribution $p ( z _ { i } = 1 | x )$ can be calculated efficiently in linear-time for all $i$ using message-passing, i.e. the forward-backward algorithm. These marginals allow us to calculate (2), and in doing so we implicitly sum over an exponentially-sized set of structures (i.e. all binary sequences of length $n$ ) through dynamic programming. We refer to this type of attention layer as a segmentation attention layer.
+
+Note that the forward-backward algorithm is being used as parameterized pooling (as opposed to output computation), and can be thought of as generalizing the standard attention softmax. Crucially this generalization from vector softmax to forward-backward is just a series of differentiable steps,2 and we can compute gradients of its output (marginals) with respect to its input (potentials). This will allow the structured attention model to be trained end-to-end as part of a deep model.
+
+# 3.2 EXAMPLE 2: SYNTACTIC TREE SELECTION
+
+This same approach can be used for more involved structural dependencies. One popular structure for natural language tasks is a dependency tree, which enforces a structural bias on the recursive dependencies common in many languages. In particular a dependency tree enforces that each word in a source sentence is assigned exactly one parent word (head word), and that these assignments do not cross (projective structure). Employing this bias encourages the system to make a soft-selection based on learned syntactic dependencies, without requiring linguistic annotations or a pipelined decision.
+
+A dependency parser can be partially formalized as a graphical model with the following cliques (Smith & Eisner, 2008): latent variables $z _ { i j } \in \{ 0 , 1 \}$ for all $i \neq j$ , which indicates that the $i$ -th word is the parent of the $j$ -th word (i.e. $x _ { i } \to x _ { j } ,$ ); and a special global constraint that rules out configurations of $z _ { i j }$ ’s that violate parsing constraints (e.g. one head, projectivity).
+
+The parameters to the graph-based CRF dependency parser are the potentials $\theta _ { i j }$ , which reflect the score of selecting $x _ { i }$ as the parent of $x _ { j }$ . The probability of a parse tree $z$ given the sentence
+
+![](images/cf212ffbbf7290198ebab24840c992265c47cb286d5c32c5fd838ecf001bfebf.jpg)
+
+Figure 2: Algorithms for linear-chain CRF: (left) computation of forward-backward tables $\alpha , \beta$ , and marginal probabilities $p$ from potentials $\theta$ (forward-backward algorithm); (right) backpropagation of loss gradients with respect to the marginals $\nabla _ { p } ^ { \mathcal { L } }$ . $\mathcal { C }$ denotes the state space and $\langle t \rangle$ is the special start/stop state. Backpropagation uses the identity $\nabla _ { \log p } ^ { \mathcal { L } } = p \odot \nabla _ { p } ^ { \mathcal { L } }$ to calculate $\nabla _ { \theta } ^ { \mathcal { L } } = \nabla _ { \log p } ^ { \mathcal { L } } \nabla _ { \theta } ^ { \log p }$ , where $\odot$ is the element-wise multiplication. Typically the forward-backward with marginals is performed in the log-space semifield $\mathbb { R } \cup \{ \pm \infty \}$ with binary operations $\oplus = \log \mathrm { a d d }$ and $\otimes = +$ for numerical precision. However, backpropagation requires working with the log of negative values (since $\nabla _ { p } ^ { \mathcal { L } }$ could be negative), so we extend to a field $[ \mathbb { R } \cup \{ \pm \infty \} ] \times \{ + , - \}$ with special $+ / -$ log-space operations. Binary operations applied to vectors are implied to be element-wise. The signexp function is defined as $\mathrm { s i g n e x p } ( l _ { a } ) = s _ { a } \exp ( l _ { a } )$ . See Section 3.3 and Table 1 for more details.
+
+$x = [ x _ { 1 } , \ldots , x _ { n } ]$ is,
+
+$$
+p ( z \mid x , q ) = { \mathrm { s o f t m a x } } \left( \mathbb { 1 } \{ z { \mathrm { ~ i s ~ v a l i d } } \} \sum _ { i \neq j } \mathbb { 1 } \{ z _ { i j } = 1 \} \theta _ { i j } \right)
+$$
+
+where $z$ is represented as a vector of $z _ { i j }$ ’s for all $i \neq j$ . It is possible to calculate the marginal probability of each edge $p ( z _ { i j } = 1 | x , q )$ for all $i , j$ in $O ( n ^ { 3 } )$ time using the inside-outside algorithm (Baker, 1979) on the data structures of Eisner (1996).
+
+The parsing contraints ensure that each word has exactly one head (i.e. $\textstyle \sum _ { i = 1 } ^ { n } z _ { i j } = 1 )$ ). Therefore if we want to utilize the soft-head selection of a position $j$ , the context vector is defined as:
+
+$$
+f _ { j } ( x , z ) = \sum _ { i = 1 } ^ { n } \mathbb { 1 } \{ z _ { i j } = 1 \} \mathbf { x } _ { i } \qquad \mathbf { c } _ { j } = \mathbb { E } _ { z } [ f _ { j } ( x , z ) ] = \sum _ { i = 1 } ^ { n } p ( z _ { i j } = 1 | x , q ) \mathbf { x } _ { i }
+$$
+
+Note that in this case the annotation function has the subscript $j$ to produce a context vector for each word in the sentence. Similar types of attention can be applied for other tree properties (e.g. soft-children). We refer to this type of attention layer as a syntactic attention layer.
+
+# 3.3 END-TO-END TRAINING
+
+Graphical models of this form have been widely used as the final layer of deep models. Our contribution is to argue that these networks can be added within deep networks in place of simple attention layers. The whole model can then be trained end-to-end.
+
+The main complication in utilizing this approach within the network itself is the need to backpropagate the gradients through an inference algorithm as part of the structured attention network. Past work has demonstrated the techniques necessary for this approach (see Stoyanov et al. (2011)), but to our knowledge it is very rarely employed.
+
+Consider the case of the simple linear-chain CRF layer from equation (3). Figure 2 (left) shows the standard forward-backward algorithm for computing the marginals $p ( z _ { i } = 1 | x , q ; \theta )$ . If we treat the forward-backward algorithm as a neural network layer, its input are the potentials $\theta$ , and its output after the forward pass are these marginals.3 To backpropagate a loss through this layer we need to compute the gradient of the loss $\mathcal { L }$ with respect to $\theta$ , $\grave { \nabla } _ { \theta } ^ { \mathcal { L } }$ , as a function of the gradient of the loss with respect to the marginals, $\nabla _ { p } ^ { \mathcal { L } }$ .4 As the forward-backward algorithm consists of differentiable steps, this function can be derived using reverse-mode automatic differentiation of the forward-backward algorithm itself. Note that this reverse-mode algorithm conveniently has a parallel structure to the forward version, and can also be implemented using dynamic programming.
+
+However, in practice, one cannot simply use current off-the-shelf tools for this task. For one, efficiency is quite important for these models and so the benefits of handoptimizing the reverse-mode implementation still outweighs simplicity of automatic differentiation. Secondly, numerical precision becomes a major issue for structured attention networks. For computing the forward-pass and the marginals, it is important to use the standard log-space semifield over $\mathbb { R } \cup \{ \pm \infty \}$ with binary operations $\oplus = \mathrm { { l o g a d d } , \otimes = + ) }$ to avoid underflow of probabilities. For computing the backward-pass, we need to remain in log
+
+Table 1: Signed log-space semifield (from Li & Eisner (2009)). Each real number $a$ is represented as a pair $( l _ { a } , s _ { a } )$ where $l _ { a } = \log \left| a \right|$ and $s _ { a } = \bar { \mathrm { s i g n } } ( a )$ . Therefore $a = s _ { a } \exp ( l _ { a } )$ . For the above we let $d = \exp ( l _ { b } - l _ { a } )$ and assume $| a | > | b |$ .   
+
+<table><tr><td></td><td colspan="3"></td><td colspan="2">区</td></tr><tr><td>Sa</td><td>Sb</td><td>④ la+b</td><td>Sa+b</td><td>la·b</td><td>Sa·b</td></tr><tr><td>+</td><td>+</td><td>la +log(1+d)</td><td>+</td><td>la+lb</td><td>十</td></tr><tr><td>+</td><td>1</td><td>la+log(1-d)</td><td>+</td><td>la+lb</td><td></td></tr><tr><td>1</td><td>+</td><td>la+log(1-d)</td><td></td><td>la+lb</td><td></td></tr><tr><td>1</td><td>1</td><td>la +log(1+d)</td><td></td><td>la+lb</td><td>+</td></tr></table>
+
+space, but also handle log of negative values (since $\nabla _ { p } ^ { \mathcal { L } }$ could be negative). This requires extending to the signed log-space semifield over $[ \mathbb { R } \cup \{ \pm \infty \} ] \stackrel { \cdot } { \times } \{ + , - \}$ with special $+ / -$ operations. Table 1, based on Li & Eisner (2009), demonstrates how to handle this issue, and Figure 2 (right) describes backpropagation through the forward-backward algorithm. For dependency parsing, the forward pass can be computed using the inside-outside implementation of Eisner’s algorithm (Eisner, 1996). Similarly, the backpropagation parallels the inside-outside structure. Forward/backward pass through the inside-outside algorithm is described in Appendix B.
+
+# 4 EXPERIMENTS
+
+We experiment with three instantiations of structured attention networks on four different tasks: (a) a simple, synthetic tree manipulation task using the syntactic attention layer, (b) machine translation with segmentation attention (i.e. two-state linear-chain CRF), (c) question answering using an $n$ - state linear-chain CRF for multi-step inference over $n$ facts, and (d) natural language inference with syntactic tree attention. These experiments are not intended to boost the state-of-the-art for these tasks but to test whether these methods can be trained effectively in an end-to-end fashion, can yield improvements over standard selection-based attention, and can learn plausible latent structures. All model architectures, hyperparameters, and training details are further described in Appendix A.
+
+# 4.1 TREE TRANSDUCTION
+
+The first set of experiments look at a tree-transduction task. These experiments use synthetic data to explore a failure case of soft-selection attention models. The task is to learn to convert a random formula given in prefix notation to one in infix notation, e.g.,
+
+The alphabet consists of symbols $\{ ( , ) , + , * \}$ , numbers between 0 and 20, and a special root symbol $\$ 1$ . This task is used as a preliminary task to see if the model is able to learn the implicit tree structure on the source side. The model itself is an encoder-decoder model, where the encoder is defined below and the decoder is an LSTM. See Appendix A.2 for the full model.
+
+![](images/8072f45bcaed1d141798e872f31d04cb3abc827f1fc32179ccb0f4267d2f9446.jpg)  
+Figure 3: Visualization of the source self-attention distribution for the simple (left) and structured (right) attention models on the tree transduction task. $\$ 8$ is the special root symbol. Each row delineates the distribution over the parents (i.e. each row sums to one). The attention distribution obtained from the parsing marginals are more able to capture the tree structure—e.g. the attention weights of closing parentheses are generally placed on the opening parentheses (though not necessarily on a single parenthesis).
+
+Training uses 15K prefix-infix pairs where the maximum nesting depth is set to be between 2-4 (the above example has depth 3), with 5K pairs in each depth bucket. The number of expressions in each parenthesis is limited to be at most 4. Test uses 1K unseen sequences with depth between 2-6 (note specifically deeper than train), with 200 sequences for each depth. The performance is measured as the average proportion of correct target tokens produced until the first failure (as in Grefenstette et al. (2015)).
+
+For experiments we try using different forms of self -attention over embedding-only encoders. Let $\mathbf { x } _ { j }$ be an embedding for each source symbol; our three variants of the source representation $\hat { \mathbf { x } } _ { j }$ are: (a) no atten, just symbol embeddings by themselves, i.e. $\hat { \mathbf { x } } _ { j } = \mathbf { x } _ { j }$ ; (b) simple attention, symbol embeddings and soft-pairing for each symbol, i.e. $\hat { \mathbf { x } } _ { j } = [ \mathbf { x } _ { j } ; \mathbf { \bar { c } } _ { j } ]$ where $\begin{array} { r } { \mathbf { c } _ { j } = \dot { \sum } _ { i = 1 } ^ { n } \mathrm { s o f t m a x } ( \mathbf { \dot { \boldsymbol { \theta } } } _ { i j } ) \mathbf { x } _ { i } } \end{array}$ is calculated using soft-selection; (c) structured attention, symbol embeddings and soft-parent, i.e. $\hat { \bf x } _ { j } = [ { \bf x } _ { j } ; { \bf c } _ { j } ]$ where $\begin{array} { r } { \mathbf { c } _ { j } = \sum _ { i = 1 } ^ { n } p ( z _ { i j } = 1 | x ) \mathbf { x } _ { i } } \end{array}$ is calculated using parsing marginals, obtained from the syntactic attention layer. None of these models use an explicit query value—the potentials come from running a bidirectional LSTM over the source, producing hidden vectors $\mathbf { h } _ { i }$ , and then computing
+
+$$
+\theta _ { i j } = \operatorname { t a n h } ( \mathbf { s } ^ { \top } \operatorname { t a n h } ( \mathbf { W } _ { 1 } \mathbf { h } _ { i } + \mathbf { W } _ { 2 } \mathbf { h } _ { j } + \mathbf { b } ) )
+$$
+
+where $\mathbf { s } , \mathbf { b } , \mathbf { W } _ { 1 } , \mathbf { W } _ { 2 }$ are parameters (see Appendix A.1).
+
+The source representation $\left[ \hat { \mathbf { x } } _ { 1 } , \ldots , \hat { \mathbf { x } } _ { n } \right]$ are attended over using the standard attention mechanism at each decoding step by an LSTM decoder.5 Additionally, symbol embedding parameters are shared between the parsing LSTM and the source encoder.
+
+Table 2: Performance (average length to failure $\%$ ) of models on the tree-transduction task.   
+
+<table><tr><td>Depth</td><td>No Atten</td><td>Simple</td><td>Structured</td></tr><tr><td>2</td><td>7.6</td><td>87.4</td><td>99.2</td></tr><tr><td>3</td><td>4.1</td><td>49.6</td><td>87.0</td></tr><tr><td>4</td><td>2.8</td><td>23.3</td><td>64.5</td></tr><tr><td>5</td><td>2.1</td><td>15.0</td><td>30.8</td></tr><tr><td>6</td><td>1.5</td><td>8.5</td><td>18.2</td></tr></table>
+
+Results Table 2 has the results for the task. Note that this task is fairly difficult as the encoder is quite simple. The baseline model (unsurprisingly) performs poorly as it has no information about the source ordering. The simple attention model performs better, but is significantly outperformed by the structured model with a tree structure bias. We hypothesize that the model is partially reconstructing the arithmetic tree. Figure 3 shows the attention distribution for the simple/structured models on the same source sequence, which indicates that the structured model is able to learn boundaries (i.e. parentheses).
+
+# 4.2 NEURAL MACHINE TRANSLATION
+
+Our second set of experiments use a full neural machine translation model utilizing attention over subsequences. Here both the encoder/decoder are LSTMs, and we replace standard simple attention with a segmentation attention layer. We experiment with two settings: translating directly from unsegmented Japanese characters to English words (effectively using structured attention to perform soft word segmentation), and translating from segmented Japanese words to English words (which can be interpreted as doing phrase-based neural machine translation). Japanese word segmentation is done using the KyTea toolkit (Neubig et al., 2011).
+
+The data comes from the Workshop on Asian Translation (WAT) (Nakazawa et al., 2016). We randomly pick 500K sentences from the original training set (of 3M sentences) where the Japanese sentence was at most 50 characters and the English sentence was at most 50 words. We apply the same length filter on the provided validation/test sets for evaluation. The vocabulary consists of all tokens that occurred at least 10 times in the training corpus.
+
+The segmentation attention layer is a two-state CRF where the unary potentials at the $j$ -th decoder step are parameterized as
+
+$$
+\theta _ { i } ( k ) = \left\{ \begin{array} { l l } { \mathbf { h } _ { i } \mathbf { W } \mathbf { h } _ { j } , } & { k = 1 } \\ { 0 , } & { k = 0 } \end{array} \right.
+$$
+
+Here $[ \mathbf { h } _ { 1 } , \ldots , \mathbf { h } _ { n } ]$ are the encoder hidden states and $\mathbf { h } _ { j } ^ { \prime }$ is the $j$ -th decoder hidden state (i.e. the query vector). The pairwise potentials are parameterized linearly with $\mathbf { b }$ , i.e. all together
+
+$$
+\theta _ { i , i + 1 } ( z _ { i } , z _ { i + 1 } ) = \theta _ { i } ( z _ { i } ) + \theta _ { i + 1 } ( z _ { i + 1 } ) + \mathbf { b } _ { z _ { i } , z _ { i + 1 } }
+$$
+
+Therefore the segmentation attention layer requires just 4 additional parameters. Appendix A.3 describes the full model architecture.
+
+We experiment with three attention configurations: (a) standard simple attention, i.e. $\mathrm { ~ \bf ~ c ~ } _ { j } = { \bf \frac { \pi } { \pi } }$ $\sum _ { i = 1 } ^ { n } \mathrm { { { s o f t m a x } } } ( \theta _ { i } ) \mathbf { h } _ { i }$ ; (b) sigmoid attention: multiple selection with Bernoulli random variables, i.e. $\begin{array} { r } { \mathbf { c } _ { j } = \sum _ { i = 1 } ^ { n } \mathrm { s i g m o i d } ( \theta _ { i } ) \mathbf { h } _ { i } } \end{array}$ ; (c) structured attention, encoded with normalized CRF marginals,
+
+$$
+\mathbf { c } _ { j } = \sum _ { i = 1 } ^ { n } \frac { p ( z _ { i } = 1 | x , q ) } { \gamma } \mathbf { h } _ { i } \qquad \gamma = \frac { 1 } { \lambda } \sum _ { i = 1 } ^ { n } p ( z _ { i } = 1 | x , q )
+$$
+
+The normalization term $\gamma$ is not ideal but we found it to be helpful for stable training.6 $\lambda$ is a hyperparameter (we use $\lambda = 2$ ) and we further add an $l _ { 2 }$ penalty of 0.005 on the pairwise potentials b. These values were found via grid search on the validation set.
+
+Table 3: Translation performance as measured by BLEU (higher is better) on characterto-word and word-to-word Japanese-English translation for the three different models.   
+
+<table><tr><td></td><td>Simple</td><td>Sigmoid</td><td> Structured</td></tr><tr><td>CHAR</td><td>12.6</td><td>13.1</td><td>14.6</td></tr><tr><td>WORD</td><td>14.1</td><td>13.8</td><td>14.3</td></tr></table>
+
+Results Results for the translation task on the test set are given in Table 3. Sigmoid attention outperforms simple (softmax) attention on the character-toword task, potentially because it is able to learn manyto-one alignments. On the word-to-word task, the opposite is true, with simple attention outperforming sigmoid attention. Structured attention outperforms both models on both tasks, although improvements on the word-to-word task are modest and unlikely to be statistically significant.
+
+For further analysis, Figure 4 shows a visualization of the different attention mechanisms on the character-to-word setup. The simple model generally focuses attention heavily on a single character. In contrast, the sigmoid and structured models are able to spread their attention distribution on contiguous subsequences. The structured attention learns additional parameters (i.e. b) to smooth out this type of attention.
+
+![](images/01cf72046b3248d5b66c418e6cd7163ab8e1f95091d95dd617a8310251335624.jpg)  
+Figure 4: Visualization of the source attention distribution for the simple (top left), sigmoid (top right), and structured (bottom left) attention models over the ground truth sentence on the character-to-word translation task. Manually-annotated alignments are shown in bottom right. Each row delineates the attention weights over the source sentence at each step of decoding. The sigmoid/structured attention models are able learn an implicit segmentation model and focus on multiple characters at each time step.
+
+# 4.3 QUESTION ANSWERING
+
+Our third experiment is on question answering (QA) with the linear-chain CRF attention layer for inference over multiple facts. We use the bAbI dataset (Weston et al., 2015), where the input is a set of sentences/facts paired with a question, and the answer is a single token. For many of the tasks the model has to attend to multiple supporting facts to arrive at the correct answer (see Figure 5 for an example), and existing approaches use multiple ‘hops’ to greedily attend to different facts. We experiment with employing structured attention to perform inference in a non-greedy way. As the ground truth supporting facts are given in the dataset, we are able to assess the model’s inference accuracy.
+
+The baseline (simple) attention model is the End-To-End Memory Network (Sukhbaatar et al., 2015) (MemN2N), which we briefly describe here. See Appendix A.4 for full model details. Let $\mathbf { x } _ { 1 } , \ldots , \mathbf { x } _ { n }$ be the input embedding vectors for the $n$ sentences/facts and let $\mathbf { q }$ be the query embedding. In MemN2N, $z _ { k }$ is the random variable for the sentence to select at the $k$ -th inference step (i.e. $k$ -th hop), and thus $z _ { k } \in \{ 1 , \ldots , n \}$ . The probability distribution over $z _ { k }$ is given by $p ( z _ { k } =$ $i \mid x , q ) = \mathrm { s o f t m a x } ( ( \mathbf { x } _ { i } ^ { k } ) ^ { \top } \mathbf { q } ^ { k } )$ , and the context vector is given by $\begin{array} { r } { \mathbf { c } ^ { k } = \sum _ { i = 1 } ^ { n } p ( \bar { z } _ { k } = i \bar { | x , q ) } \mathbf { o } _ { i } ^ { k } } \end{array}$ , where $\mathbf { x } _ { i } ^ { k } , \mathbf { o } _ { i } ^ { k }$ are the input and output embedding for the $i$ -th sentence at the $k$ -th hop, respectively. The $k$ -th context vector is used to modify the query $\mathbf { q } ^ { k + 1 } = \mathbf { q } ^ { k } + \mathbf { c } ^ { k }$ , and this process repeats for $k = 1 , \ldots , K$ (for $k = 1$ we have $\mathbf { x } _ { i } ^ { k } = \mathbf { \bar { x } } _ { i } , \mathbf { q } ^ { k ^ { - } } = \mathbf { \bar { q } } , \bar { \mathbf { c } } ^ { k } = \mathbf { 0 } )$ . The $K$ -th context and query vectors are used to obtain the final answer. The attention mechanism for a $K$ -hop MemN2N network can therefore be interpreted as a greedy selection of a length- $K$ sequence of facts (i.e. $z _ { 1 } , \dotsc , z _ { K } )$ .
+
+For structured attention, we use an $n$ -state, $K$ -step linear-chain CRF.7 We experiment with two different settings: (a) a unary CRF model with node potentials
+
+$$
+\theta _ { k } ( i ) = ( \mathbf { x } _ { i } ^ { k } ) ^ { \top } \mathbf { q } ^ { k }
+$$
+
+Table 4: Answer accuracy (Ans $\%$ ) and supporting fact selection accuracy (Fact $\%$ ) of the three QA models on the 1K bAbI dataset. $K$ indicates the number of hops/inference steps used for each task. Task 7 and 8 both contain variable number of facts and hence they are excluded from the fact accuracy measurement. Supporting fact selection accuracy is calculated by taking the average of 10 best runs (out of 20) for each task.   
+
+<table><tr><td></td><td></td><td colspan="2">MemN2N</td><td colspan="2">Binary CRF</td><td colspan="2">Unary CRF</td></tr><tr><td>Task</td><td>K</td><td>Ans %</td><td>Fact %</td><td>Ans %</td><td>Fact %</td><td>Ans %</td><td>Fact %</td></tr><tr><td>TASK O2-TWO SUPPORTING FACTS</td><td>2</td><td>87.3</td><td>46.8</td><td>84.7</td><td>81.8</td><td>43.5</td><td>22.3</td></tr><tr><td>TASK O3 -THREE SUPPORTING FACTS</td><td>3</td><td>52.6</td><td>1.4</td><td>40.5</td><td>0.1</td><td>28.2</td><td>0.0</td></tr><tr><td>TASK 07 - COUNTING</td><td>3</td><td>83.2</td><td>1</td><td>83.5</td><td>1</td><td>79.3</td><td>1</td></tr><tr><td>TASK O8 -LISTS SETS</td><td>3</td><td>94.1</td><td>1</td><td>93.3</td><td>1</td><td>87.1</td><td>一</td></tr><tr><td>TASK11- INDEFINITE KNOWLEDGE</td><td>2</td><td>97.8</td><td>38.2</td><td>97.7</td><td>80.8</td><td>88.6</td><td>0.0</td></tr><tr><td>TASK 13 - COMPOUND COREFERENCE</td><td>2</td><td>95.6</td><td>14.8</td><td>97.0</td><td>36.4</td><td>94.4</td><td>9.3</td></tr><tr><td>TASK14 - TIME REASONING</td><td>2</td><td>99.9</td><td>77.6</td><td>99.7</td><td>98.2</td><td>90.5</td><td>30.2</td></tr><tr><td>TASK 15 - BASIC DEDUCTION</td><td>2</td><td>100.0</td><td>59.3</td><td>100.0</td><td>89.5</td><td>100.0</td><td>51.4</td></tr><tr><td>TASK 16 -BASIC INDUCTION</td><td>3</td><td>97.1</td><td>91.0</td><td>97.9</td><td>85.6</td><td>98.0</td><td>41.4</td></tr><tr><td>TASK17 - POSITIONAL REASONING</td><td>2</td><td>61.1</td><td>23.9</td><td>60.6</td><td>49.6</td><td>59.7</td><td>10.5</td></tr><tr><td>TASK 18 - SIZE REASONING</td><td>2</td><td>86.4</td><td>3.3</td><td>92.2</td><td>3.9</td><td>92.0</td><td>1.4</td></tr><tr><td>TASK 19 - PATH FINDING</td><td>2</td><td>21.3</td><td>10.2</td><td>24.4</td><td>11.5</td><td>24.3</td><td>7.8</td></tr><tr><td>AVERAGE</td><td>1</td><td>81.4</td><td>39.6</td><td>81.0</td><td>53.7</td><td>73.8</td><td>17.4</td></tr></table>
+
+and (b) a binary CRF model with pairwise potentials
+
+$$
+\theta _ { k , k + 1 } ( i , j ) = ( \mathbf { x } _ { i } ^ { k } ) ^ { \top } \mathbf { q } ^ { k } + ( \mathbf { x } _ { i } ^ { k } ) ^ { \top } \mathbf { x } _ { j } ^ { k + 1 } + ( \mathbf { x } _ { j } ^ { k + 1 } ) ^ { \top } \mathbf { q } ^ { k + 1 }
+$$
+
+The binary CRF model is designed to test the model’s ability to perform sequential reasoning. For both (a) and (b), a single context vector is computed: $\begin{array} { r } { \mathbf { c } = \sum _ { z _ { 1 } , \dots , z _ { K } } p ( z _ { 1 } , \dots , z _ { K } \mid x , q ) f ( x , z ) } \end{array}$ (unlike MemN2N which computes $K$ context vectors). Evaluating c requires summing over all $n ^ { K }$ possible sequences of length $K$ , which may not be practical for large values of $K$ . However, if $f ( x , z )$ factors over the components of $z$ (e.g. $\begin{array} { r } { f ( x , z ) = \sum _ { k = 1 } ^ { K } f _ { k } ( x , z _ { k } ) ) } \end{array}$ then one can rewrite the above sum in terms of marginals: $\begin{array} { r } { \mathbf { c } = \sum _ { k = 1 } ^ { K } \sum _ { i = 1 } ^ { n } p ( z _ { k } = i | x , q ) f _ { k } ( x , z _ { k } ) } \end{array}$ . In our experiments, we use $f _ { k } ( x , z _ { k } ) = \mathbf { o } _ { z _ { k } } ^ { k }$ . All three models are described in further detail in Appendix A.4.
+
+Results We use the version of the dataset with 1K questions for each task. Since all models reduce to the same network for tasks with 1 supporting fact, they are excluded from our experiments. The number of hops (i.e. $K$ ) is task-dependent, and the number of memories (i.e. $^ { n ) }$ is limited to be at most 25 (note that many question have less than 25 facts—e.g. the example in Figure 5 has 9 facts). Due to high variance in model performance, we train 20 models with different initializations for each task and report the test accuracy of the model that performed the best on a $1 0 \%$ held-out validation set (as is typically done for bAbI tasks).
+
+Results of the three different models are shown in Table 4. For correct answer seletion (Ans $\%$ ), we find that MemN2N and the Binary CRF model perform similarly while the Unary CRF model does worse, indicating the importance of including pairwise potentials. We also assess each model’s ability to attend to the correct supporting facts in Table 4 (Fact $\%$ ). Since ground truth supporting facts are provided for each query, we can check the sequence accuracy of supporting facts for each model (i.e. the rate of selecting the exact correct sequence of facts) by taking the highest probability sequence $\hat { z } =$ argmax $p ( z _ { 1 } , \dots , z _ { K } \mid x , q )$ from the model and checking against the ground truth. Overall the Binary CRF is able to recover supporting facts better than MemN2N. This improvement is significant and can be up to two-fold as seen for task 2, 11, 13 & 17. However we observed that on many tasks it is sufficient to select only the last (or first) fact correctly to predict the answer, and thus higher sequence selection accuracy does not necessarily imply better answer accuracy (and vice versa). For example, all three models get $1 0 0 \%$ answer accuracy on task 15 but have different supporting fact accuracies.
+
+Finally, in Figure 5 we visualize of the output edge marginals produced by the Binary CRF model for a single question in task 16. In this instance, the model is uncertain but ultimately able to select the right sequence of facts $5  6  8$ .
+
+![](images/436aeea6818457c319a736ebf1815d87cc18bc41e7eb6f6580f9fc3f6c3fc796.jpg)  
+Correct Facts:5.6.8   
+Figure 5: Visualization of the attention distribution over supporting fact sequences for an example question in task 16 for the Binary CRF model. The actual question is displayed at the bottom along with the correct answer and the ground truth supporting facts $5  6  8$ ). The edges represent the marginal probabilities $p ( z _ { k } , z _ { k + 1 } \mid x , q )$ , and the nodes represent the $n$ supporting facts (here we have $n = 9$ ). The text for the supporting facts are shown on the left. The top three most likely sequences are: $p ( z _ { 1 } = 5 , z _ { 2 } = 6 , z _ { 3 } =$ $8 \hat { | x , q ) = } 0 . 0 5 6 4$ , $p ( z _ { 1 } = 5 , z _ { 2 } = 6 , z _ { 3 } = 3 | { \bar { x } } , q ) = 0 . 0 3 6 4 , p ( z _ { 1 } = 5 , z _ { 2 } = 2 , z _ { 3 } = 3 | x , q ) = 0 . 0 3 5 6$ .
+
+# 4.4 NATURAL LANGUAGE INFERENCE
+
+The final experiment looks at the task of natural language inference (NLI) with the syntactic attention layer. In NLI, the model is given two sentences (hypothesis/premise) and has to predict their relationship: entailment, contradiction, neutral.
+
+For this task, we use the Stanford NLI dataset (Bowman et al., 2015) and model our approach off of the decomposable attention model of Parikh et al. (2016). This model takes in the matrix of word embeddings as the input for each sentence and performs inter-sentence attention to predict the answer. Appendix A.5 describes the full model.
+
+As in the transduction task, we focus on modifying the input representation to take into account soft parents via self-attention (i.e. intra-sentence attention). In addition to the three baselines described for tree transduction (No Attention, Simple, Structured), we also explore two additional settings: (d) hard pipeline parent selection, i.e. $\hat { \mathbf { x } } _ { j } = [ \mathbf { x } _ { j } ; \mathbf { x } _ { \mathrm { h e a d } ( j ) } ]$ , where ${ \mathrm { h e a d } } ( j )$ is the index of $x _ { j }$ ’s parent8; (e) pretrained structured attention: structured attention where the parsing layer is pretrained for one epoch on a parsed dataset (which was enough for convergence).
+
+Results Results of our models are shown in Table 5. Simple attention improves upon the no attention model, and this is consistent with improvements observed by Parikh et al. (2016) with their intra-sentence attention model. The pipelined model with hard parents also slightly improves upon the baseline. Structured attention outperforms both models, though surprisingly, pretraining the syntactic attention layer on the parse trees performs worse than training it from scratch—it is possible that the pretrained attention is too strict for this task.
+
+We also obtain the hard parse for an example sentence by running the Viterbi algorithm on the syntactic attention layer with the non-pretrained model:
+
+![](images/b9e81f522fe75acc234b0590a93684b898735d122f79720961efd8eaf65637ce.jpg)
+
+Table 5: Results of our models (bottom) and others (top) on the Stanford NLI test set. Our baseline model has the same architecture as Parikh et al. (2016) but the performance is slightly different due to different settings (e.g. we train for 100 epochs with a batch size of 32 while Parikh et al. (2016) train for 400 epochs with a batch size of 4 using asynchronous SGD.)   
+
+<table><tr><td>Model</td><td>Accuracy %</td></tr><tr><td>Handcrafted features (Bowman et al.,2015)</td><td>78.2</td></tr><tr><td>LSTM encoders (Bowman et al.,2015)</td><td>80.6</td></tr><tr><td>Tree-Based CNN (Mou et al.,2016)</td><td>82.1</td></tr><tr><td>Stack-Augmented Parser-Interpreter Neural Net (Bowman et al., 2016)</td><td>83.2</td></tr><tr><td>LSTM with word-by-word attention (Rocktäschel et al., 2016)</td><td>83.5</td></tr><tr><td>MatchingLSTMs (Wang &amp; Jiang,2016)</td><td>86.1</td></tr><tr><td>Decomposable attention over word embeddings (Parikh et al., 2016)</td><td>86.3</td></tr><tr><td>Decomposable attention + intra-sentence attention (Parikh et al.,2016)</td><td>86.8</td></tr><tr><td>Attention over constituency tree nodes (Zhao et al.,2016)</td><td>87.2</td></tr><tr><td>Neural Tree Indexers (Munkhdalai &amp; Yu,2016)</td><td>87.3</td></tr><tr><td>Enhanced BiLSTMInference Model (Chen et al.,2016)</td><td>87.7</td></tr><tr><td>Enhanced BiLSTM Inference Model + ensemble (Chen et al.,2016)</td><td>88.3</td></tr><tr><td>No Attention</td><td>85.8</td></tr><tr><td>No Attention +Hard parent</td><td>86.1</td></tr><tr><td>Simple Attention</td><td>86.2</td></tr><tr><td>Structured Attention</td><td>86.8</td></tr><tr><td>Pretrained Structured Attention</td><td>86.5</td></tr></table>
+
+Despite being trained without ever being exposed to an explicit parse tree, the syntactic attention layer learns an almost plausible dependency structure. In the above example it is able to correctly identify the main verb fighting, but makes mistakes on determiners (e.g. head of The should be men). We generally observed this pattern across sentences, possibly because the verb structure is more important for the inference task.
+
+# 5 CONCLUSION
+
+This work outlines structured attention networks, which incorporate graphical models to generalize simple attention, and describes the technical machinery and computational techniques for backpropagating through models of this form. We implement two classes of structured attention layers: a linear-chain CRF (for neural machine translation and question answering) and a more complicated first-order dependency parser (for tree transduction and natural language inference). Experiments show that this method can learn interesting structural properties and improve on top of standard models. Structured attention could also be a way of learning latent labelers or parsers through attention on other tasks.
+
+It should be noted that the additional complexity in computing the attention distribution increases run-time—for example, structured attention was approximately $5 \times$ slower to train than simple attention for the neural machine translation experiments, even though both attention layers have the same asymptotic run-time (i.e. $O ( n )$ ).
+
+Embedding differentiable inference (and more generally, differentiable algorithms) into deep models is an exciting area of research. While we have focused on models that admit (tractable) exact inference, similar technique can be used to embed approximate inference methods. Many optimization algorithms (e.g. gradient descent, LBFGS) are also differentiable (Domke, 2012; Maclaurin et al., 2015), and have been used as output layers for structured prediction in energy-based models (Belanger & McCallum, 2016; Wang et al., 2016). Incorporating them as internal neural network layers is an interesting avenue for future work.
+
+# ACKNOWLEDGMENTS
+
+We thank Tao Lei, Ankur Parikh, Tim Vieira, Matt Gormley, Andre Martins, Jason Eisner, Yoav ´ Goldberg, and the anonymous reviewers for helpful comments, discussion, notes, and code. We additionally thank Yasumasa Miyamoto for verifying Japanese-English translations.
+
+# REFERENCES
+
+Daniel Andor, Chris Alberti, David Weiss, Aliaksei Severyn, Alessandro Presta, Kuzman Ganchev, Slav Petrov, and Michael Collins. Globally Normalized Transition-Based Neural Networks. In Proceedings of ACL, 2016.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural Machine Translation by Jointly Learning to Align and Translate. In Proceedings of ICLR, 2015.
+
+James K. Baker. Trainable Grammars for Speech Recognition. Speech Communication Papers for the 97th Meeting of the Acoustical Society, 1979.
+
+David Belanger and Andrew McCallum. Structured Prediction Energy Networks. In Proceedings of ICML, 2016.
+
+Samuel R. Bowman, Christopher D. Manning, and Christopher Potts. Tree-Structured Composition in Neural Networks without Tree-Structured Architectures. In Proceedings of the NIPS workshop on Cognitive Computation: Integrating Neural and Symbolic Approaches, 2015.
+
+Samuel R. Bowman, Jon Gauthier, Abhinav Rastogi, Raghav Gupta, Christopher D. Manning, and Christopher Potts. A Fast Unified Model for Parsing and Sentence Understanding. In Proceedings of ACL, 2016.
+
+William Chan, Navdeep Jaitly, Quoc Le, and Oriol Vinyals. Listen, Attend and Spell. arXiv:1508.01211, 2015.
+
+Liang-Chieh Chen, Alexander G. Schwing, Alan L. Yuille, and Raquel Urtasun. Learning Deep Structured Models. In Proceedings of ICML, 2015.
+
+Qian Chen, Xiaodan Zhu, Zhenhua Ling, Si Wei, and Hui Jiang. Enhancing and Combining Sequential and Tree LSTM for Natural Language Inference. arXiv:1609.06038, 2016.
+
+Kyunghyun Cho, Aaron Courville, and Yoshua Bengio. Describing Multimedia Content using Attention-based Encoder-Decoder Networks. In IEEE Transactions on Multimedia, 2015.
+
+Jan Chorowski, Dzmitry Bahdanau, Dmitriy Serdyuk, Kyunghyun Cho, and Yoshua Bengio. Attention-Based Models for Speech Recognition. In Proceedings of NIPS, 2015.
+
+Ronan Collobert, Jason Weston, Leon Bottou, Michael Karlen, Koray Kavukcuoglu, and Pavel Kuksa. Natural Language Processing (almost) from Scratch. Journal of Machine Learning Research, 12:2493–2537, 2011.
+
+Trinh-Minh-Tri Do and Thierry Artieres. Neural Conditional Random Fields. In ´ Proceedings of AISTATS, 2010.
+
+Justin Domke. Parameter Learning with Truncated Message-Passing. In Proceedings of CVPR, 2011.
+
+Justin Domke. Generic methods for optimization-based modeling. In AISTATS, pp. 318–326, 2012.
+
+John Duchi, Elad Hazan, and Yoram Singer. Adaptive Subgradient Methods for Online Learning and Stochastic Optimization. Journal of Machine Learning Research, 12:2021–2159, 2011.
+
+Greg Durrett and Dan Klein. Neural CRF Parsing. In Proceedings of ACL, 2015.
+
+Jason M. Eisner. Three New Probabilistic Models for Dependency Parsing: An Exploration. In Proceedings of ACL, 1996.
+
+Jason M. Eisner. Inside-Outside and Forward-Backward Algorithms are just Backprop. In Proceedings of Structured Prediction Workshop at EMNLP, 2016.
+
+Matthew R. Gormley, Mark Dredze, and Jason Eisner. Approximation-Aware Dependency Parsing by Belief Propagation. In Proceedings of TACL, 2015.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural Turing Machines. arXiv:1410.5401, 2014.
+
+Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka GrabskaBarwinska, Sergio Gomez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, Adria Puigdomenech Badia, Karl Moritz Hermann, Yori Zwols, Georg Ostrovski, Adam Cain, Helen King, Christopher Summerfield, Phil Blunsom, Koray Kavukcuoglu, and Demis Hassabis. Hybrid Computing Using a Neural Network with Dynamic External Memory. Nature, October 2016.
+
+Edward Grefenstette, Karl Moritz Hermann, Mustafa Suleyman, and Phil Blunsom. Learning to Transduce with Unbounded Memory. In Proceedings of NIPS, 2015.
+
+Karl Moritz Hermann, Tomas Kocisky, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa Suleyman, and Phil Blunsom. Teaching Machines to Read and Comprehend. In Proceedings of NIPS, 2015.
+
+Max Jaderberg, Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep Structured Output Learning for Unconstrained Text Recognition. In Proceedings of ICLR, 2014.
+
+Diederik Kingma and Jimmy Ba. Adam: A Method for Stochastic Optimization. In Proceedings of ICLR, 2015.
+
+Eliyahu Kipperwasser and Yoav Goldberg. Simple and Accurate Dependency Parsing using Bidirectional LSTM Feature Representations. In TACL, 2016.
+
+Lingpeng Kong, Chris Dyer, and Noah A. Smith. Segmental Recurrent Neural Networks. In Proceedings of ICLR, 2016.
+
+John Lafferty, Andrew McCallum, and Fernando Pereira. Conditional Random Fields: Probabilistic Models for Segmenting and Labeling Sequence Data. In Proceedings of ICML, 2001.
+
+Guillaume Lample, Miguel Ballesteros, Sandeep Subramanian, Kazuya Kawakami, and Chris Dyer. Neural Architectures for Named Entity Recognition. In Proceedings of NAACL, 2016.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based Learning Applied to Document Recognition. In Proceedings of IEEE, 1998.
+
+Zhifei Li and Jason Eisner. First- and Second-Order Expectation Semirings with Applications to Minimum-Risk Training on Translation Forests. In Proceedings of EMNLP 2009, 2009.
+
+Liang Lu, Lingpeng Kong, Chris Dyer, Noah A. Smith, and Steve Renals. Segmental Recurrent Neural Networks for End-to-End Speech Recognition. In Proceedings of INTERSPEECH, 2016.
+
+Minh-Thang Luong, Hieu Pham, and Christopher D. Manning. Effective Approaches to Attentionbased Neural Machine Translation. In Proceedings of EMNLP, 2015.
+
+Dougal Maclaurin, David Duvenaud, and Ryan P. Adams. Gradient-based Hyperparameter Optimization through Reversible Learning. In Proceedings of ICML, 2015.
+
+Lili Mou, Rui Men, Ge Li, Yan Xu, Lu Zhang, Rui Yan, and Zhi Jin. Natural language inference by tree-based convolution and heuristic matching. In Proceedings of ACL, 2016.
+
+Tsendsuren Munkhdalai and Hong Yu. Neural Tree Indexers for Text Understanding. arxiv:1607.04492, 2016.
+
+Toshiaki Nakazawa, Manabu Yaguchi, Kiyotaka Uchimoto, Masao Utiyama, Eiichiro Sumita, Sadao Kurohashi, and Hitoshi Isahara. Aspec: Asian scientific paper excerpt corpus. In Nicoletta Calzolari (Conference Chair), Khalid Choukri, Thierry Declerck, Marko Grobelnik, Bente Maegaard, Joseph Mariani, Asuncion Moreno, Jan Odijk, and Stelios Piperidis (eds.), Proceedings of the Ninth International Conference on Language Resources and Evaluation (LREC 2016), pp. 2204– 2208, Portoro, Slovenia, may 2016. European Language Resources Association (ELRA). ISBN 978-2-9517408-9-1.
+
+Graham Neubig, Yosuke Nakata, and Shinsuke Mori. Pointwise Prediction for Robust, Adaptable Japanese Morphological Analysis. In Proceedings of ACL, 2011.
+
+Ankur P. Parikh, Oscar Tackstrom, Dipanjan Das, and Jakob Uszkoreit. A Decomposable Attention Model for Natural Language Inference. In Proceedings of EMNLP, 2016.
+
+Jian Peng, Liefeng Bo, and Jinbo Xu. Conditional Neural Fields. In Proceedings of NIPS, 2009.
+
+Jeffrey Pennington, Richard Socher, and Christopher D. Manning. GloVe: Global Vectors for Word Representation. In Proceedings of EMNLP, 2014.
+
+Tim Rocktaschel, Edward Grefenstette, Karl Moritz Hermann, Tomas Kocisky, and Phil Blunsom. ¨ Reasoning about Entailment with Neural Attention. In Proceedings of ICLR, 2016.
+
+John Schulman, Nicolas Heess, Theophane Weber, and Pieter Abbeel. Gradient estimation using stochastic computation graphs. In Advances in Neural Information Processing Systems, pp. 3528– 3536, 2015.
+
+David A. Smith and Jason Eisner. Dependency Parsing as Belief Propagation. In Proceedings of EMNLP, 2008.
+
+Veselin Stoyanov and Jason Eisner. Minimum-Risk Training of Approximate CRF-based NLP Systems. In Proceedings of NAACL, 2012.
+
+Veselin Stoyanov, Alexander Ropson, and Jason Eisner. Empirical Risk Minimization of Graphical Model Parameters Given Approximate Inference, Decoding, and Model Structure. In Proceedings of AISTATS, 2011.
+
+Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. End-To-End Memory Networks. In Proceedings of NIPS, 2015.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer Networks. In Proceedings of NIPS, 2015.
+
+Shenlong Wang, Sanja Fidler, and Raquel Urtasun. Proximal Deep Structured Models. In Proceedings of NIPS, 2016.
+
+Shuohang Wang and Jing Jiang. Learning Natural Language Inference with LSTM. In Proceedings of NAACL, 2016.
+
+Jason Weston, Sumit Chopra, and Antoine Bordes. Memory Networks. arXiv:1410.3916, 2014.
+
+Jason Weston, Antoine Bordes, Sumit Chopra, Alexander M Rush, Bart van Merrienboer, Armand ¨ Joulin, and Tomas Mikolov. Towards Ai-complete Question Answering: A Set of Prerequisite Toy Tasks. arXiv preprint arXiv:1502.05698, 2015.
+
+Kelvin Xu, Jimma Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhutdinov, Richard Zemel, and Yoshua Bengio. Show, Attend and Tell: Neural Image Caption Generation with Visual Attention. In Proceedings of ICML, 2015.
+
+Lei Yu, Jan Buys, and Phil Blunsom. Online Segment to Segment Neural Transduction. In Proceedings of EMNLP, 2016.
+
+Lei Yu, Phil Blunsom, Chris Dyer, Edward Grefenstette, and Tomas Kocisky. The Neural Noisy Channel. In Proceedings of ICLR, 2017.
+
+Kai Zhao, Liang Huang, and Minbo Ma. Textual Entailment with Structured Attentions and Composition. In Proceedings of COLING, 2016.
+
+# APPENDICES
+
+A MODEL DETAILS
+
+# A.1 SYNTACTIC ATTENTION
+
+The syntactic attention layer (for tree transduction and natural language inference) is similar to the first-order graph-based dependency parser of Kipperwasser & Goldberg (2016). Given an input sentence $[ x _ { 1 } , \ldots , x _ { n } ]$ and the corresponding word vectors $\left[ \mathbf { x } _ { 1 } , \ldots , \mathbf { x } _ { n } \right]$ , we use a bidirectional LSTM to get the hidden states for each time step $i \in [ 1 , \ldots , n ]$ ,
+
+$$
+\begin{array} { r } { \mathbf { h } _ { i } ^ { \mathrm { f w d } } = \mathrm { L S T M } ( \mathbf { x } _ { i } , \mathbf { h } _ { i - 1 } ^ { \mathrm { f w d } } ) \qquad \mathbf { h } _ { i } ^ { \mathrm { b w d } } = \mathrm { L S T M } ( \mathbf { x } _ { i } , \mathbf { h } _ { i + 1 } ^ { \mathrm { b w d } } ) \qquad \mathbf { h } _ { i } = [ \mathbf { h } _ { i } ^ { \mathrm { f w d } } ; \mathbf { h } _ { i } ^ { \mathrm { b w d } } ] } \end{array}
+$$
+
+where the forward and backward LSTMs have their own parameters. The score for $x _ { i } \to x _ { j }$ (i.e. $x _ { i }$ is the parent of $x _ { j }$ ), is given by an MLP
+
+$$
+\theta _ { i j } = \operatorname { t a n h } ( \mathbf { s } ^ { \top } \operatorname { t a n h } ( \mathbf { W } _ { 1 } \mathbf { h } _ { i } + \mathbf { W } _ { 2 } \mathbf { h } _ { j } + \mathbf { b } ) )
+$$
+
+These scores are used as input to the inside-outside algorithm (see Appendix B) to obtain the probability of each word’s parent $p ( z _ { i j } = 1 | x )$ , which is used to obtain the soft-parent $\mathbf { c } _ { j }$ for each word $x _ { j }$ . In the non-structured case we simply have $p ( z _ { i j } = 1 | x ) = \mathrm { s o f t m a x } ( \theta _ { i j } )$ .
+
+# A.2 TREE TRANSDUCTION
+
+Let $[ x _ { 1 } , \ldots , x _ { n } ]$ , $[ y _ { 1 } , \dots , y _ { m } ]$ be the sequence of source/target symbols, with the associated embeddings $\left[ \mathbf { x } _ { 1 } , \ldots , \mathbf { x } _ { n } \right]$ , $\left[ \mathbf { y } _ { 1 } , \ldots , \mathbf { y } _ { m } \right]$ with $\bar { \mathbf { \eta } } _ { \bar { \mathbf { \eta } } _ { i } , \mathbf { \bar { y } } _ { j } } \in \mathbb { R } ^ { l }$ . In the simplest baseline model we take the source representation to be the matrix of the symbol embeddings. The decoder is a one-layer LSTM which produces the hidden states $\mathbf h _ { j } ^ { \prime } = \mathrm { L S T M } ( \mathbf y _ { j } , \mathbf h _ { j - 1 } ^ { \prime } )$ , with $\mathbf { h } _ { j } ^ { \prime } \in \mathbb { R } ^ { l }$ . The hidden states are combined with the input representation via a bilinear map $\mathbf { W } \in \mathbb { R } ^ { l \times l }$ to produce the attention distribution used to obtain the vector $\mathbf { m } _ { i }$ , which is combined with the decoder hidden state as follows,
+
+$$
+\alpha _ { i } = { \frac { \exp \mathbf { x } _ { i } \mathbf { W } \mathbf { h } _ { j } ^ { \prime } } { \sum _ { k = 1 } ^ { n } \exp \mathbf { x } _ { k } \mathbf { W } \mathbf { h } _ { j } ^ { \prime } } } { \mathbf { m } _ { i } = \sum _ { i = 1 } ^ { n } \alpha _ { i } \mathbf { x } _ { i } }  { \hat { \mathbf { h } } } _ { j } = { \mathrm { t a n h } } ( \mathbf { U } [ \mathbf { m } _ { i } ; \mathbf { h } _ { j } ^ { \prime } ] )
+$$
+
+Here we have $\mathbf { W } \in \mathbb { R } ^ { l \times l }$ and $\mathbf { U } \in \mathbb { R } ^ { 2 l \times l }$ . Finally, $\hat { \mathbf { h } } _ { j }$ is used to to obtain a distribution over the next symbol $y _ { j + 1 }$ ,
+
+$$
+p ( y _ { j + 1 } \mid x _ { 1 } , \dots , x _ { n } , y _ { 1 } , \dots , y _ { j } ) = \mathrm { s o f t m a x } ( \mathbf { V } \hat { \mathbf { h } } _ { j } + \mathbf { b } )
+$$
+
+For structured/simple models, the $j$ -th source representation are respectively
+
+$$
+\hat { \mathbf { x } } _ { i } = \left[ \mathbf { x } _ { i } ; \sum _ { k = 1 } ^ { n } p ( z _ { k i } = 1 | x ) \mathbf { x } _ { k } \right] \qquad \quad \hat { \mathbf { x } } _ { i } = \left[ \mathbf { x } _ { i } ; \sum _ { k = 1 } ^ { n } \mathrm { s o f t m a x } ( \theta _ { k i } ) \mathbf { x } _ { k } \right]
+$$
+
+where $\theta _ { i j }$ comes from the bidirectional LSTM described in A.1. Then $\alpha _ { i }$ and $\mathbf { m } _ { i }$ changed accordingly,
+
+$$
+\alpha _ { i } = \frac { \exp \hat { \mathbf { x } } _ { i } \mathbf { W } \mathbf { h } _ { j } ^ { \prime } } { \sum _ { k = 1 } ^ { n } \exp \hat { \mathbf { x } } _ { k } \mathbf { W } \mathbf { h } _ { j } ^ { \prime } } \qquad \quad \mathbf { m } _ { i } = \sum _ { i = 1 } ^ { n } \alpha _ { i } \hat { \mathbf { x } } _ { i }
+$$
+
+Note that in this case we have $\mathbf { W } \in \mathbb { R } ^ { 2 l \times l }$ and $\mathbf { U } \in \mathbb { R } ^ { 3 l \times l }$ . We use $l = 5 0$ in all our experiments. The forward/backward LSTMs for the parsing LSTM are also 50-dimensional. Symbol embeddings are shared between the encoder and the parsing LSTMs.
+
+Additional training details include: batch size of 20; training for 13 epochs with a learning rate of 1.0, which starts decaying by half after epoch 9 (or the epoch at which performance does not improve on validation, whichever comes first); parameter initialization over a uniform distribution $U [ - 0 . 1 , 0 . 1 ]$ ; gradient normalization at 1 (i.e. renormalize the gradients to have norm 1 if the $l _ { 2 }$ norm exceeds 1). Decoding is done with beam search (beam size $= 5$ ).
+
+# A.3 NEURAL MACHINE TRANSLATION
+
+The baseline NMT system is from Luong et al. (2015). Let $[ x _ { 1 } , \ldots , x _ { n } ]$ , $[ y _ { 1 } , \dots , y _ { m } ]$ be the source/target sentence, with the associated word embeddings $[ { \bf x } _ { 1 } , \ldots , { \bf x } _ { n } ] , [ { \bf y } _ { 1 } , \ldots , { \bf y } _ { m } ] .$ The encoder is an LSTM over the source sentence, which produces the hidden states $[ \mathbf { h } _ { 1 } , \ldots , \mathbf { h } _ { n } ]$ where
+
+$$
+\mathbf h _ { i } = \mathrm { L S T M } ( \mathbf x _ { i } , \mathbf h _ { i - 1 } )
+$$
+
+and $\mathbf { h } _ { i } \in \mathbb { R } ^ { l }$ . The decoder is another LSTM which produces the hidden states $\mathbf { h } _ { j } ^ { \prime } \in \mathbb { R } ^ { l }$ . In the simple attention case with categorical attention, the hidden states are combined with the input representation via a bilinear map $\mathbf { W } \in \mathbb { R } ^ { l \times l }$ and this distribution is used to obtain the context vector at the $j$ -th time step,
+
+$$
+\theta _ { i } = \mathbf { h } _ { i } \mathbf { W } \mathbf { h } _ { j } ^ { \prime } \ \mathbf { \epsilon } \qquad \mathbf { c } _ { j } = \sum _ { i = 1 } ^ { n } \mathrm { s o f t m a x } ( \theta _ { i } ) \mathbf { h } _ { i }
+$$
+
+The Bernoulli attention network has the same $\theta _ { i }$ but instead uses a sigmoid to obtain the weights of the linear combination, i.e.,
+
+$$
+\mathbf { c } _ { j } = \sum _ { i = 1 } ^ { n } \mathrm { s i g m o i d } ( \theta _ { i } ) \mathbf { h } _ { i }
+$$
+
+And finally, the structured attention model uses a bilinear map to parameterize one of the unary potentials
+
+$$
+\theta _ { i } ( k ) = \left\{ \begin{array} { l l } { \mathbf { h } _ { i } \mathbf { W } \mathbf { h } _ { j } ^ { \prime } , } & { k = 1 } \\ { 0 , } & { k = 0 } \end{array} \right.
+$$
+
+$$
+\theta _ { i , i + 1 } ( z _ { i } , z _ { i + 1 } ) = \theta _ { i } ( z _ { i } ) + \theta _ { i + 1 } ( z _ { i + 1 } ) + \mathbf { b } _ { z _ { i } , z _ { i + 1 } }
+$$
+
+where $\mathbf { b }$ are the pairwise potentials. These potentials are used as inputs to the forward-backward algorithm to obtain the marginals $p ( z _ { i } = 1 | x , q )$ , which are further normalized to obtain the context vector
+
+$$
+\mathbf { c } _ { j } = \sum _ { i = 1 } ^ { n } \frac { p ( z _ { i } = 1 | x , q ) } { \gamma } \mathbf { h } _ { i } \qquad \gamma = \frac { 1 } { \lambda } \sum _ { i } ^ { n } p ( z _ { i } = 1 | x , q )
+$$
+
+We use $\lambda = 2$ and also add an $l _ { 2 }$ penalty of 0.005 on the pairwise potentials $\mathbf { b }$ . The context vector is then combined with the decoder hidden state
+
+$$
+\hat { \mathbf { h } } _ { j } = \operatorname { t a n h } ( \mathbf { U } [ \mathbf { c } _ { j } ; \mathbf { h } _ { j } ^ { \prime } ] )
+$$
+
+and $\hat { \mathbf { h } } _ { j }$ is used to obtain the distribution over the next target word $y _ { j + 1 }$
+
+$$
+p ( y _ { j + 1 } \mid x _ { 1 } , \ldots , x _ { n } , y _ { 1 } , \ldots y _ { j } ) = \mathrm { s o f t m a x } ( \mathbf { V } \hat { \mathbf { h } } _ { j } + \mathbf { b } )
+$$
+
+The encoder/decoder LSTMs have 2 layers and 500 hidden units (i.e. $l = 5 0 0$ ).
+
+Additional training details include: batch size of 128; training for 30 epochs with a learning rate of 1.0, which starts decaying by half after the first epoch at which performance does not improve on validation; dropout with probability 0.3; parameter initialization over a uniform distribution $U [ - 0 . 1 , 0 . 1 ]$ ; gradient normalization at 1. We generate target translations with beam search (beam $\mathrm { s i z e } = 5$ ), and evaluate with multi-bleu.perl from Moses.9
+
+# A.4 QUESTION ANSWERING
+
+Our baseline model (MemN2N) is implemented following the same architecture as described in Sukhbaatar et al. (2015). In particular, let $x = [ x _ { 1 } , \ldots , x _ { n } ]$ represent the sequence of $n$ facts with the associated embeddings $\left[ \mathbf { x } _ { 1 } , \ldots , \mathbf { x } _ { n } \right]$ and let $\mathbf { q }$ be the embedding of the query $q$ . The embeddings
+
+are obtained by simply adding the word embeddings in each sentence or query. The full model with $K$ hops is as follows:
+
+$$
+\begin{array} { r l } & { p ( z _ { k } = i | x , q ) = \mathrm { s o f t m a x } ( ( \mathbf { x } _ { i } ^ { k } ) ^ { \top } \mathbf { q } ^ { k } ) } \\ & { \mathbf { c } ^ { k } = \displaystyle \sum _ { i = 1 } ^ { n } p ( z _ { k } = i | x , q ) \mathbf { o } _ { i } ^ { k } } \\ & { \mathbf { q } ^ { k + 1 } = \mathbf { q } ^ { k } + \mathbf { c } ^ { k } } \\ & { p ( y | x , q ) = \mathrm { s o f t m a x } ( \mathbf { W } ( \mathbf { q } ^ { K } + \mathbf { c } ^ { K } ) ) } \end{array}
+$$
+
+where $p ( y \mid x , q )$ is the distribution over the answer vocabulary. At each layer, $\{ \mathbf { x } _ { i } ^ { k } \}$ and $\{ \mathbf { o } _ { i } ^ { k } \}$ are computed using embedding matrices $\mathbf { X } ^ { k }$ and $\mathbf { O } ^ { k }$ . We use the adjacent weight tying scheme from the paper so that $\mathbf { X } ^ { k + 1 } = \mathbf { \check { O } } ^ { k }$ , $\mathbf { W } ^ { T } = \mathbf { O } ^ { K }$ . $\mathbf { X } ^ { 1 }$ is also used to compute the query embedding at the first hop. For $k = 1$ we have $\mathbf { x } _ { i } ^ { k } = \mathbf { x } _ { i } , \mathbf { q } ^ { k } = \mathbf { q } , \mathbf { c } ^ { k } = \mathbf { 0 }$ .
+
+For both the Unary and the Binary CRF models, the same input fact and query representations are computed (i.e. same embedding matrices with weight tying scheme). For the unary model, the potentials are parameterized as
+
+$$
+\theta _ { k } ( i ) = ( \mathbf { x } _ { i } ^ { k } ) ^ { \top } \mathbf { q } ^ { k }
+$$
+
+and for the binary model we compute pairwise potentials as
+
+$$
+\theta _ { k , k + 1 } ( i , j ) = ( \mathbf { x } _ { i } ^ { k } ) ^ { \top } \mathbf { q } ^ { k } + ( \mathbf { x } _ { i } ^ { k } ) ^ { \top } \mathbf { x } _ { j } ^ { k + 1 } + ( \mathbf { x } _ { j } ^ { k + 1 } ) ^ { \top } \mathbf { q } ^ { k + 1 }
+$$
+
+The $\mathbf { q } ^ { k }$ ’s are updated simply with a linear mapping, i.e.
+
+$$
+\mathbf { q } ^ { k + 1 } = \mathbf { Q } \mathbf { q } ^ { k }
+$$
+
+In the case of the Binary CRF, to discourage the model from selecting the same fact again we additionally set $\theta _ { k , k + 1 } ( i , i ) = - \infty$ for all $i \in \{ 1 , \ldots , n \}$ . Given these potentials, we compute the marginals $p ( z _ { k } = i , z _ { k + 1 } = j | x , q )$ using the forward-backward algorithm, which is then used to compute the context vector:
+
+$$
+\mathbf { c } = \sum _ { z _ { 1 } , \ldots , z _ { K } } p ( z _ { 1 } , \ldots , z _ { K } | x , q ) f ( x , z ) \qquad f ( x , z ) = \sum _ { k = 1 } ^ { K } f _ { k } ( x , z _ { k } ) \qquad f _ { k } ( x , z _ { k } ) = \mathbf { o } _ { z _ { k } } ^ { k }
+$$
+
+Note that if $f ( x , z )$ factors over the components of $z$ (as is the case above) then computing c only requires evaluating the marginals $p ( \boldsymbol { z } _ { k } | \boldsymbol { x } , \boldsymbol { q } )$ .
+
+Finally, given the context vector the prediction is made in a similar fashion to MemN2N:
+
+$$
+p ( \boldsymbol { y } \mid \boldsymbol { x } , \boldsymbol { q } ) = \mathrm { s o f t m a x } ( \mathbf { W } ( \mathbf { q } ^ { K } + \mathbf { c } ) )
+$$
+
+Other training setup is similar to Sukhbaatar et al. (2015): we use stochastic gradient descent with learning rate 0.01, which is divided by 2 every 25 epochs until 100 epochs are reached. Capacity of the memory is limited to 25 sentences. The embedding vectors are of size 20 and gradients are renormalized if the norm exceeds 40. All models implement position encoding, temporal encoding, and linear start from the original paper. For linear start, the softmax $( \cdot )$ function in the attention layer is removed at the beginning and re-inserted after 20 epochs for MemN2N, while for the CRF models we apply a $\log ( \operatorname { s o f t m a x } ( \cdot ) )$ layer on the $\mathbf { q } ^ { k }$ after 20 epochs. Each model is trained separately for each task.
+
+# A.5 NATURAL LANGUAGE INFERENCE
+
+Our baseline model/setup is essentially the same as that of Parikh et al. (2016). Let $[ x _ { 1 } , \ldots , x _ { n } ]$ , $[ y _ { 1 } , \dots , y _ { m } ]$ be the premise/hypothesis, with the corresponding input representations $\left[ \mathbf { x } _ { 1 } , \ldots , \mathbf { x } _ { n } \right]$ , $[ \mathbf { y } _ { 1 } , \ldots , \mathbf { y } _ { m } ]$ . The input representations are obtained by a linear transformation of the 300-dimensional pretrained GloVe embeddings (Pennington et al., 2014) after normalizing the GloVe embeddings to have unit norm.10 The pretrained embeddings remain fixed but the linear layer (which is also 300-dimensional) is trained. Words not in the pretrained vocabulary are hashed to one of 100 Gaussian embeddings with mean 0 and standard deviation 1.
+
+We concatenate each input representation with a convex combination of the other sentence’s input representations (essentially performing inter-sentence attention), where the weights are determined through a dot product followed by a softmax,
+
+$$
+e _ { i j } = f ( \mathbf { x } _ { i } ) ^ { \top } f ( \mathbf { y } _ { j } ) \quad \bar { \mathbf { x } } _ { i } = \left[ \mathbf { x } _ { i } ; \sum _ { j = 1 } ^ { m } \frac { \exp e _ { i j } } { \sum _ { k = 1 } ^ { m } \exp e _ { i k } } \mathbf { y } _ { j } \right] \quad \bar { \mathbf { y } } _ { j } = \left[ \mathbf { y } _ { j } ; \sum _ { i = 1 } ^ { n } \frac { \exp e _ { i j } } { \sum _ { k = 1 } ^ { n } \exp e _ { k j } } \mathbf { x } _ { i } \right]
+$$
+
+Here $f ( \cdot )$ is an MLP. The new representations are fed through another $\mathrm { { M L P } } g ( \cdot )$ , summed, combined with the final MLP $h ( \cdot )$ and fed through a softmax layer to obtain a distribution over the labels $l$ ,
+
+$$
+\begin{array} { c } { \displaystyle { \bar { \bf x } = \sum _ { i = 1 } ^ { n } g ( \bar { \bf x } _ { i } ) \qquad \bar { \bf y } = \sum _ { j = 1 } ^ { m } g ( \bar { \bf y } _ { j } ) } } \\ { { p ( l \mid x _ { 1 } , \dots , x _ { n } , y _ { 1 } , \dots , y _ { m } ) = \mathrm { s o f t m a x } ( { \bf V } h ( [ \bar { \bf x } ; \bar { \bf y } ] ) + { \bf b } ) } } \end{array}
+$$
+
+All the MLPs have 2-layers, 300 ReLU units, and dropout probability of 0.2. For structured/simple models, we first employ the bidirectional parsing LSTM (see A.1) to obtain the scores $\theta _ { i j }$ . In the structured case each word representation is simply concatenated with its soft-parent
+
+$$
+{ \hat { \mathbf { x } } } _ { i } = \left[ \mathbf { x } _ { i } ; \sum _ { k = 1 } ^ { n } p ( z _ { k i } = 1 | x ) \mathbf { x } _ { k } \right]
+$$
+
+and $\hat { \mathbf { x } } _ { i }$ (and analogously $\hat { \mathbf { y } } _ { j }$ ) is used as the input to the above model. In the simple case (which closely corresponds to the intra-sentence attention model of Parikh et al. (2016)), we have
+
+$$
+{ \hat { \mathbf { x } } } _ { i } = \left[ \mathbf { x } _ { i } ; \sum _ { k = 1 } ^ { n } { \frac { \exp { \theta _ { k i } } } { \sum _ { l = 1 } ^ { n } { \exp { \theta _ { l i } } } } } \mathbf { x } _ { k } \right]
+$$
+
+The word embeddings for the parsing LSTMs are also initialized with GloVe, and the parsing layer is shared between the two sentences. The forward/backward LSTMs for the parsing layer are 100- dimensional.
+
+Additional training details include: batch size of 32; training for 100 epochs with Adagrad (Duchi et al., 2011) where the global learning rate is 0.05 and sum of gradient squared is initialized to 0.1; parameter intialization over a Gaussian distribution with mean 0 and standard deviation 0.01; gradient normalization at 5. In the pretrained scenario, pretraining is done with Adam (Kingma & Ba, 2015) with learning rate equal to 0.01, and $\beta _ { 1 } = 0 . 9$ , $\beta _ { 2 } = 0 . 9 9 9$ .
+
+# B FORWARD/BACKWARD THROUGH THE INSIDE-OUTSIDE ALGORITHM
+
+Figure 6 shows the procedure for obtaining the parsing marginals from the input potentials. This corresponds to running the inside-outside version of Eisner’s algorithm (Eisner, 1996). The intermediate data structures used during the dynamic programming algorithm are the (log) inside tables $\alpha$ , and the (log) outside tables $\beta$ . Both $\alpha , \beta$ are of size $n \times n \times 2 \times 2$ , where $n$ is the sentence length. First two dimensions encode the start/end index of the span (i.e. subtree). The third dimension encodes whether the root of the subtree is the left $( L )$ or right $( R )$ index of the span. The fourth dimension indicates if the span is complete (1) or incomplete (0). We can calculate the marginal distribution of each word’s parent (for all words) in $O ( n ^ { 3 } ) $ using this algorithm.
+
+Backward pass through the inside-outside algorithm is slightly more involved, but still takes $O ( n ^ { 3 } )$ time. Figure 7 illustrates the backward procedure, which receives the gradient of the loss $\mathcal { L }$ with respect to the marginals, $\nabla _ { p } ^ { \mathcal { L } }$ , and computes the gradient of the loss with respect to the potentials $\nabla _ { \theta } ^ { \mathcal { L } }$ . The computations must be performed in the signed log-space semifield to handle log of negative values. See section 3.3 and Table 1 for more details.
+
+rocedure INSIDEOUTSIDE(θ) $\alpha , \beta \gets - \infty$ . Initialize log of inside $( \alpha )$ , outside $( \beta )$ tables for $i = 1 , \ldots , n$ do α[i, i, L, 1] ← 0 α[i, i, R, 1] ← 0 $\beta [ 1 , n , R , 1 ] \gets 0$ for $k = 1 , \dots , n$ do . Inside step for $s = 1 , \ldots , n - k$ do t ← s + k $\begin{array} { r l } & { t  s + k } \\ & { \alpha [ s , t , R , 0 ]  \bigoplus _ { u \in [ s , t - 1 ] } \alpha [ s , u , R , 1 ] \otimes \alpha [ u + 1 , t , L , 1 ] \otimes \theta _ { s t } } \\ & { \alpha [ s , t , L , 0 ]  \bigoplus _ { u \in [ s , t - 1 ] } \alpha [ s , u , R , 1 ] \otimes \alpha [ u + 1 , t , L , 1 ] \otimes \theta _ { t s } } \\ & { \alpha [ s , t , R , 1 ]  \bigoplus _ { u \in [ s + 1 , t ] } \alpha [ s , u , R , 0 ] \otimes \alpha [ u , t , R , 1 ] } \\ & { \alpha [ s , t , L , 1 ]  \bigoplus _ { u \in [ s , t - 1 ] } \alpha [ s , u , L , 1 ] \otimes \alpha [ u , t , L , 0 ] } \end{array}$ for $k = n , \ldots , 1$ do . Outside step for f $\begin{array} { r l } & { \mathrm { ~ \beta ~ = 1 , \dots , } n - k { \bf d o } } \\ & { \mathrm { ~ \beta ~  ~ } s + k } \\ & { \mathrm { ~ \bf \delta r ~ } u = s + 1 , \dots , t { \bf d o } } \\ & { \mathrm { ~ \beta ~ \beta ~ \beta ~ \geq ~ } \phi \mathrm { ~ \beta ~ } \beta [ s , t , R , 1 ] \otimes \alpha [ u , t , R , 1 ] } \\ & { \mathrm { ~ \beta ~ \beta ~ \geq ~ } \phi [ u , t , R , 1 ]  _ { \Phi } \mathrm { ~ \beta ~ } \beta [ s , t , R , 1 ] \otimes \alpha [ s , u , R , 0 ] } \end{array}$ if $s > 1$ then for $u = s , \ldots , t - 1$ do fo $\begin{array} { r l } & { \qquad \mathrm { s o r ~ } \qquad \omega \mathrm { , ~ } \qquad \mathrm { , ~ } \qquad \mathrm { ~ } \qquad \mathrm { , ~ } \qquad \qquad \mathrm { ~ } \qquad } \\ & { \qquad \beta [ s , u , L , 1 ] \gets \oplus \beta [ s , t , L , 1 ] \otimes \alpha [ u , t , L , 0 ] } \\ & { \qquad \beta [ u , t , L , 0 ] \gets \oplus \beta [ s , t , L , 1 ] \otimes \alpha [ s , u , L , 1 ] } \\ & { \qquad \cdot u = s , \qquad , \mathrm { ~ } t - 1 \mathrm { ~ d } \mathbf { 0 } } \\ & { \qquad \beta [ s , u , R , 1 ] \gets \oplus \beta [ s , t , R , 0 ] \otimes \alpha [ u + 1 , t , L , 1 ] \otimes \theta _ { s t } } \\ & { \qquad \beta [ u + 1 , t , L , 1 ] \gets \oplus \beta [ s , t , R , 0 ] \otimes \alpha [ s , u , R , 1 ] \otimes \theta _ { s t } } \end{array}$ if $s > 1$ then fo $\begin{array} { r l } & { \mathbf { \langle } u = s , \ldots , t - 1 \mathbf { { d } 0 } } \\ & { \mathbf { \langle } \beta [ s , u , R , 1 ] \gets \oplus \beta [ s , t , L , 0 ] \otimes \alpha [ u + 1 , t , L , 1 ] \otimes \theta _ { t s } } \\ & { \mathbf { \ } \beta [ u + 1 , t , L , 1 ] \gets \oplus \beta [ s , t , L , 0 ] \otimes \alpha [ s , u , R , 1 ] \otimes \theta _ { t s } } \end{array}$ $A  \alpha [ 1 , n , R , 1 ]$ . Log partition   
+for $s = 1 , \ldots , n - 1$ do . Compute marginals. Note that $p [ s , t ] = p ( z _ { s t } = 1 | x )$ for $t = s + 1 , \ldots , n$ do $\begin{array} { r l } & { p [ s , t ]  \ell \mathrm { e x p } ( \alpha [ s , t , R , 0 ] \otimes \beta [ s , t , R , 0 ] \otimes - A ) } \\ & { \mathbf { i f } s > 1 \mathbf { t h e n } } \\ & { \qquad p [ t , s ]  \mathrm { e x p } ( \alpha [ s , t , L , 0 ] \otimes \beta [ s , t , L , 0 ] \otimes - A ) } \end{array}$   
+return p   
+rocedure BACKPROPINSIDEOUTSIDE $( \theta , p , \nabla _ { p } ^ { \mathcal { L } } )$   
+for $s , t = 1 , . . . , n ; s \neq t$ do . Backpropagation uses the identity $\nabla _ { \theta } ^ { \mathcal { L } } = ( p \odot \nabla _ { p } ^ { \mathcal { L } } ) \nabla _ { \theta } ^ { \log p }$ $\delta [ s , t ] \longleftrightarrow \log p [ s , t ] \otimes \log \nabla _ { p } ^ { \mathcal { L } } [ s , t ]$ $\ u \triangleright \delta = \log ( p \odot \nabla _ { p } ^ { \mathcal { L } } )$   
+$\nabla _ { \alpha } ^ { \mathcal { L } } , \nabla _ { \beta } ^ { \mathcal { L } } , \log \nabla _ { \theta } ^ { \mathcal { L } }  \infty$ . Initialize inside $( \nabla _ { \alpha } ^ { \mathcal { L } } )$ , outside $( \nabla _ { \beta } ^ { \mathcal { L } } )$ gradients, and log of $\nabla _ { \theta } ^ { \mathcal { L } }$   
+for $s = 1 , \ldots , n - 1$ do . Backpropagate $\delta$ to $\nabla _ { \alpha } ^ { \mathcal { L } }$ and $\nabla _ { \beta } ^ { \mathcal { L } }$ for $t = s + 1 , \ldots , n$ do $\begin{array} { r l } & { \nabla _ { \alpha } ^ { \mathcal { L } } [ s , t , R , 0 ] , \nabla _ { \beta } ^ { \mathcal { L } } [ s , t , R , 0 ]  \delta [ s , t ] } \\ & { \nabla _ { \alpha } ^ { \mathcal { L } } [ 1 , n , R , 1 ]  _ { \oplus } - \delta [ s , t ] } \\ & { \mathbf { i f } s > 1 \mathrm { t h e n } } \\ & { \qquad \nabla _ { \alpha } ^ { \mathcal { L } } [ s , t , L , 0 ] , \nabla _ { \beta } ^ { \mathcal { L } } [ s , t , L , 0 ]  \delta [ t , s ] } \\ & { \qquad \nabla _ { \alpha } ^ { \mathcal { L } } [ 1 , n , R , 1 ]  _ { \oplus } - \delta [ s , t ] } \end{array}$   
+for $k = 1 , \dots , n$ do . Backpropagate through outside step for $s = 1 , \ldots , n - k$ do $\begin{array} { r l } & { t  s + k } \\ & { \nu  \nabla _ { \beta } ^ { \mathcal { L } } [ s , t , R , 0 ] \otimes \beta [ s , t , R , 0 ] } \\ & { { \bf f o r } u = t , \ldots , n { \bf d o } } \\ & { \quad \nabla _ { \beta } ^ { \mathcal { L } } [ s , u , R , 1 ] , \nabla _ { \alpha } ^ { \mathcal { L } } [ t , u , R , 1 ]  _ { \oplus } \nu \otimes \beta [ s , u , R , 1 ] \otimes \alpha [ t , u , R , 1 ] } \end{array}$ $\nu , \gamma$ are temporary values if $\begin{array} { r l } & { \mathbf { f } _ { \mathbf { x } _ { 0 } } = \frac { 1 } { N } \mathbf { f } _ { \mathbf { x } _ { 1 } } , \mathbf { f } _ { \mathbf { x } _ { 0 } } = \frac { 1 } { N } \mathbf { f } _ { \mathbf { x } _ { 1 } } , \mathbf { f } _ { \mathbf { x } _ { 0 } } = \beta \left( g _ { \mathbf { x } _ { 1 } } , g _ { \mathbf { x } _ { 1 } } , g _ { \mathbf { x } _ { 1 } } \right) } \\ & { \quad + \frac { 1 } { N } \mathbf { f } _ { \mathbf { x } _ { 0 } } - \frac { 1 } { N } \mathbf { f } _ { \mathbf { x } _ { 1 } } , \mathbf { f } _ { \mathbf { x } _ { 0 } } = \frac { 1 } { N } \mathbf { f } _ { \mathbf { x } _ { 0 } } , \mathbf { f } _ { \mathbf { x } _ { 1 } } , \mathbf { f } _ { \mathbf { x } _ { 1 } } = \alpha \beta \left( g _ { \mathbf { x } _ { 1 } } , \mathbf { f } _ { \mathbf { x } _ { 1 } } \right) \beta \alpha \mathbf { f } _ { \mathbf { x } _ { 0 } } , \mathbf { f } _ { \mathbf { x } _ { 1 } } , } \\ & { \quad + \gamma \mathbf { f } _ { \mathbf { x } _ { 0 } } \left[ g _ { \mathbf { x } _ { 1 } } , \mathbf { f } _ { \mathbf { x } _ { 1 } } \right] \mathbf { f } _ { \mathbf { x } _ { 0 } } \beta \left( g _ { \mathbf { x } _ { 2 } } , \mathbf { f } _ { \mathbf { x } _ { 1 } } \right) } \\ & { \quad - \beta \left( g _ { \mathbf { x } _ { 0 } } , \mathbf { f } _ { \mathbf { x } _ { 1 } } , \mathbf { f } _ { \mathbf { x } _ { 1 } } \right) \mathbf { f } _ { \mathbf { x } _ { 0 } } \beta \left( g _ { \mathbf { x } _ { 2 } } , \mathbf { f } _ { \mathbf { x } _ { 1 } } \right) } \\ & { \quad + \frac { 1 } { N } \mathbf { f } _ { \mathbf { x } _ { 0 } } - \frac { 1 } { N } \mathbf { f } _ { \mathbf { x } _ { 0 } } , } \\ &  \quad + \alpha \left( g _ { \mathbf { x } _ { 1 } } , \mathbf { f } _ { \mathbf { x } _ { 0 } } , \mathbf { f } _ { \mathbf { x } _ { 1 } } \right) \mathbf { f } _ { \mathbf { x } _ { 0 } } \\ &  \quad +  \end{array}$   
+for $k = n , \ldots , 1$ do . Backpropagate through inside step for $s = 1 , \ldots , n - k$ do $t  s + k$ $\begin{array} { r l } & { t \gets s + \kappa } \\ & { \nu \gets \nabla _ { \alpha } ^ { \mathcal { L } } [ s , t , R , 1 ] \otimes \alpha [ s , t , R , 1 ] } \\ & { { \bf f o r } u = s + 1 , . . . , t { \bf d o } } \\ & { \qquad \nabla _ { \alpha } ^ { \mathcal { L } } [ u , t , R , 0 ] , \nabla _ { \alpha } ^ { \mathcal { L } } [ u , t , R , 1 ] \gets _ { \oplus } \nu \otimes \alpha [ s , u , R , 0 ] \otimes \alpha [ u , t , R , 1 ] } \end{array}$ if $s > 1$ then   
+r $\begin{array} { r l } & { \quad _ { \nu } \gets \nabla _ { \mathbf { x } } ^ { C } [ s , t , L , 1 ] \otimes \alpha [ s , t , L , 1 ] } \\ & { \quad \mathrm { f o r ~ } u = s , \dots , t - 1 \mathrm { ~ d } \mathbf { 0 } } \\ & { \quad \quad \mathrm { V a } [ s , u , L , 1 ] , \nabla _ { \mathbf { x } } ^ { C } [ u , l , L , 0 ] \longleftrightarrow \nu \otimes \alpha [ s , u , L , 1 ] \otimes \alpha [ u , t , L , 0 ] } \\ & { \quad _ { \nu } \gets \nabla _ { \mathbf { x } } ^ { C } [ s , t , L , 0 ] \otimes \alpha [ s , t , L , 0 ] } \\ & { \quad \mathrm { f o r ~ } u = s , \dots , t - 1 \mathrm { ~ d } \mathbf { 0 } } \\ & { \quad \quad \gamma \gets \alpha [ s , u , R , 1 ] \otimes \alpha [ u + 1 , t , L , 1 ] \otimes \theta _ { t s } } \\ & { \quad \quad \quad \nabla _ { \mathbf { x } } ^ { C } [ s , u , R , 1 ] , \nabla _ { \mathbf { x } } ^ { C } [ u + 1 , t , L , 1 ] , \log \nabla _ { \mathbf { x } } ^ { C } [ t , s ] \gets _ { \Phi } \nu \otimes \gamma } \\ & { \quad \quad _ { \nu } \gets \nabla _ { \mathbf { x } } ^ { C } [ s , t , R , 0 ] \otimes \alpha [ s , t , R , 0 ] } \\ & { \quad \quad _ { \nu } \mathrm { f o r ~ } u = s , \dots , t - 1 \mathrm { ~ d } \mathbf { 0 } } \\ & { \quad \quad \gamma \neq \alpha [ s , u , R , 1 ] \otimes \alpha [ u + 1 , t , L , 1 ] \otimes \theta _ { s t } } \\ & { \quad \quad \quad \nabla _ { \mathbf { x } } ^ { C } [ s , u , R , 1 ] , \nabla _ { \mathbf { x } } ^ { C } [ u + 1 , t , L , 1 ] , \log \nabla _ { \mathbf { x } } ^ { C } [ s , t ] \gets _ { \Phi } \nu \otimes \gamma } \\ & { \quad \quad \quad \mathrm { e x p o n e r y ~ l o g ~ V a r ~  { \alpha } } } \end{array}$ y sign, and return $\nabla _ { \theta } ^ { \mathcal { L } }$

parse/train/SkT5Yg-RZ/SkT5Yg-RZ.md

@@ -0,0 +1,366 @@
+# INTRINSIC MOTIVATION AND AUTOMATICCURRICULA VIA ASYMMETRIC SELF-PLAY
+
+Sainbayar Sukhbaatar Dept. of Computer Science New York University sainbar@cs.nyu.edu
+
+Zeming Lin   
+Facebook AI Research   
+New York   
+zlin@fb.com
+
+Ilya Kostrikov Dept. of Computer Science New York University kostrikov@cs.nyu.edu
+
+# Gabriel Synnaeve, Arthur Szlam & Rob Fergus
+
+Facebook AI Research   
+New York   
+{gab,aszlam,robfergus}@fb.com
+
+# ABSTRACT
+
+We describe a simple scheme that allows an agent to learn about its environment in an unsupervised manner. Our scheme pits two versions of the same agent, Alice and Bob, against one another. Alice proposes a task for Bob to complete; and then Bob attempts to complete the task. In this work we will focus on two kinds of environments: (nearly) reversible environments and environments that can be reset. Alice will “propose” the task by doing a sequence of actions and then Bob must undo or repeat them, respectively. Via an appropriate reward structure, Alice and Bob automatically generate a curriculum of exploration, enabling unsupervised training of the agent. When Bob is deployed on an RL task within the environment, this unsupervised training reduces the number of supervised episodes needed to learn, and in some cases converges to a higher reward.
+
+# 1 INTRODUCTION
+
+Model-free approaches to reinforcement learning are sample inefficient, typically requiring a huge number of episodes to learn a satisfactory policy. The lack of an explicit environment model means the agent must learn the rules of the environment from scratch at the same time as it tries to understand which trajectories lead to rewards. In environments where reward is sparse, only a small fraction of the agents’ experience is directly used to update the policy, contributing to the inefficiency.
+
+In this paper we introduce a novel form of unsupervised training for an agent that enables exploration and learning about the environment without any external reward that incentivizes the agents to learn how to transition between states as efficiently as possible. We demonstrate that this unsupervised training allows the agent to learn new tasks within the environment quickly.
+
+# 2 APPROACH
+
+We consider environments with a single physical agent (or multiple physical units controlled by a single agent), but we allow it to have two separate “minds”: Alice and Bob, each with its own objective and parameters. During self-play episodes, Alice’s job is to propose a task for Bob to complete, and Bob’s job is to complete the task. When presented with a target task episode, Bob is then used to perform it (Alice plays no role). The key idea is that the Bob’s play with Alice should help him understand how the environment works and enabling him to learn the target task more quickly.
+
+Our approach is restricted to two classes of environment: (i) those that are (nearly) reversible, or (ii) ones that can be reset to their initial state (at least once). These restrictions allow us to sidestep complications around how to communicate the task and determine its difficulty (see Appendix F.2 for further discussion). In these two scenarios, Alice starts at some initial state $s _ { 0 }$ and proposes a task by doing it, i.e. executing a sequence of actions that takes the agent to a state $s _ { t }$ . She then outputs a STOP action, which hands control over to Bob. In reversible environments, Bob’s goal is to return the agent back to state $s _ { 0 }$ (or within some margin of it, if the state is continuous), to receive reward. In partially observable environments, the objective is relaxed to Bob finding a state that returns the same observation as Alice’s initial state. In environments where resets are permissible, Alice’s STOP action also reinitializes the environment, thus Bob starts at $s _ { 0 }$ and now must reach $s _ { t }$ to be rewarded, thus repeating Alice’s task instead of reversing it. See Fig. 1 for an example, and also Algorithm 1 in Appendix A.
+
+![](images/7a0fb69b8512612d2b8fa5d73a06dd1b5ae9373c04f571492ab24b6a8c9031ad.jpg)  
+Bob	applied	to	target	task
+
+![](images/77c7cd4ceefc87391c2fd192d27a67f27251053c83d29d18dc2e3330d52f342f.jpg)  
+Figure 1: Illustration of the self-play concept in a gridworld setting. Training consists of two types of episode: self-play and target task. In the former, Alice and Bob take turns moving the agent within the environment. Alice sets tasks by altering the state via interaction with its objects (key, door, light) and then hands control over to Bob. He must return the environment to its original state to receive an internal reward. This task is just one of many devised by Alice, who automatically builds a curriculum of increasingly challenging tasks. In the target task, Bob’s policy is used to control the agent, with him receiving an external reward if he visits the flag. He is able to learn to do this quickly as he is already familiar with the environment from self-play.
+
+In both cases, this self-play between Alice and Bob only involves internal reward (detailed below), thus the agent can be trained without needing any supervisory signal from the environment. As such, it comprises a form of unsupervised training where Alice and Bob explore the environment and learn how it operates. This exploration can be leveraged for some target task by training Bob on target task episodes in parallel. The idea is that Bob’s experience from self-play will help him learn the target task in fewer episodes. The reason behind choosing Bob for the target task is because he learns to transfer from one state to another efficiently from self-play. See Algorithm 2 in Appendix A for detail.
+
+For self-play, we choose the reward structure for Alice and Bob to encourage Alice to push Bob past his comfort zone, but not give him impossible tasks. Denoting Bob’s total reward by $R _ { B }$ (given at the end of episodes) and Alice’s total reward by $R _ { A }$ , we use
+
+$$
+R _ { B } = - \gamma t _ { B }
+$$
+
+where $t _ { B }$ is the time taken by Bob to complete his task and
+
+$$
+R _ { A } = \gamma \operatorname* { m a x } ( 0 , t _ { B } - t _ { A } )
+$$
+
+where $t _ { A }$ is the time until Alice performs the STOP action, and $\gamma$ is a scaling coefficient that balances this internal reward to be of the same scale as external rewards from the target task. The total length of an episode is limited to $t _ { \mathrm { M a x } }$ , so if Bob fails to complete the task in time we set $t _ { B } = t _ { \mathrm { M a x } } - t _ { A }$ .
+
+Thus Alice is rewarded if Bob takes more time, but the negative term on her own time will encourage Alice not to take too many steps when Bob is failing. For both reversible and resettable environments, Alice must limit her steps to make Bob’s task easier, thus Alice’s optimal behavior is to the find simplest tasks that Bob cannot complete. This eases learning for Bob since the new task will be only just beyond his current capabilities. The self-regulating feedback between Alice and Bob allows them to automatically construct a curriculum for exploration, a key contribution of our approach.
+
+# 2.1 PARAMETERIZING ALICE AND BOB’S ACTIONS
+
+Alice and Bob each have policy functions which take as input two observations of state variables, and output a distribution over actions. In Alice’s case, the function will be of the form
+
+$$
+a _ { \mathrm { A } } = \pi _ { A } ( s _ { t } , s _ { 0 } ) ,
+$$
+
+where $s _ { 0 }$ is the observation of the initial state of the environment and $s _ { t }$ is the observation of the current state. In Bob’s case, the function will be
+
+$$
+a _ { \mathrm { B } } = \pi _ { B } ( s _ { t } , s ^ { * } ) ,
+$$
+
+where $s ^ { * }$ is the target state that Bob has to reach, and set to $s _ { 0 }$ when we have a reversible environment. In a resettable environment $s ^ { * }$ is the state where Alice executed the STOP action.
+
+When a target task is presented, the agent’s policy function is $a _ { \mathrm { T a r g e t } } = \pi _ { B } ( s _ { t } , \emptyset )$ , where the second argument of Bob’s policy is simply set to zero 1. If $s ^ { * }$ is always non-zero, then this is enough to let Bob know whether the current episode is self-play or target task. In some experiments where $s ^ { * }$ can be zero, we give third argument $z \in \{ 0 , 1 \}$ that explicitly indicates the episode kind.
+
+In the experiments below, we demonstrate our approach in settings where $\pi _ { A }$ and $\pi _ { B }$ are tabular; where it is a neural network taking discrete inputs, and where it is a neural network taking in continuous inputs. When using a neural network, we use the same network architecture for both Alice and Bob, except they have different parameters
+
+$$
+\pi _ { A } ( s _ { t } , s _ { 0 } ) = f ( s _ { t } , s _ { 0 } , \theta _ { A } ) , \quad \pi _ { B } ( s _ { t } , s ^ { \ast } ) = f ( s _ { t } , s ^ { \ast } , \theta _ { B } ) ,
+$$
+
+where $f$ is an multi-layered neural network with parameters $\theta _ { A }$ or $\theta _ { B }$ .
+
+# 2.2 UNIVERSAL BOB IN THE TABULAR SETTING
+
+We now present a theoretical argument that shows for environments with finite states, tabular policies, and deterministic, Markovian transitions, we can interpret the self-play as training Bob to find a policy that can get from any state to any other in the least expected number of steps.
+
+Preliminaries: Note that, as discussed above, the policy table for Bob is indexed by $( s _ { t } , s ^ { * } )$ , not just by $s _ { t }$ . In particular, with the assumptions above, this means that there is a fast policy $\pi _ { \mathrm { f a s t } }$ such that $\pi _ { \mathrm { f a s t } } ( s _ { t } , s ^ { * } )$ has the smallest expected number of steps to transition from $s _ { t }$ to $s ^ { * }$ . It is clear that $\pi _ { \mathrm { f a s t } }$ is a universal policy for Bob, such that $\pi _ { B } = \pi _ { \mathrm { f a s t } }$ is optimal with respect to any Alice’s policy $\pi _ { A }$ . In a reset game, $\pi _ { \mathrm { f a s t } }$ nets Alice a return of 0, and in the reverse game, the return of $\pi _ { \mathrm { f a s t } }$ against an optimal Alice can be considered a measure of the reversibility of the environment. However, in what follows let us assume that either the reset game or the reverse game in a perfectly reversible environment is used. Also, let assume the initial states are randomized and its distribution covers the entire state space.
+
+Claim: If $\pi _ { A }$ and $\pi _ { B }$ are policies of Alice and Bob that are in equilibrium (i.e., Alice cannot be made better without changing Bob, and vice-versa), then $\pi _ { B }$ is a fast policy.
+
+Argument: Let us first show that Alice will always get zero reward in equilibrium. If Alice is getting positive reward on some challenge, that means Bob is taking longer than Alice on that challenge. Then Bob can be improved to use $\pi _ { f a s t }$ at that challenge, which contradicts the equilibrium assumption.
+
+Now let us prove $\pi _ { B }$ is a fast policy by contradiction. If $\pi _ { B }$ is not fast, then there must exist a challenge $( s _ { t } , s ^ { * } )$ where $\pi _ { B }$ will take longer than $\pi _ { f a s t }$ . Therefore Bob can get more reward by using $\pi _ { f a s t }$ if Alice does propose that challenge with non-zero probability. Since we assumed equilibrium and $\pi _ { B }$ cannot be improved while $\pi _ { A }$ fixed, the only possibility is that Alice is never proposing that challenge. If that is true, Alice can get positive reward by proposing that task using the same actions as $\pi _ { f a s t }$ , so taking fewer steps than $\pi _ { B }$ . However this contradicts with the proof that Alice always gets zero reward, making our initial assumption $^ { 6 6 } \pi _ { B }$ is not fast” wrong.
+
+# 3 RELATED WORK
+
+Self-play arises naturally in reinforcement learning, and has been well studied. For example, for playing checkers (Samuel, 1959), backgammon (Tesauro, 1995), and Go, (Silver et al., 2016), and in multi-agent games such as RoboSoccer (Riedmiller et al., 2009). Here, the agents or teams of agents compete for external reward. This differs from our scheme where the reward is purely internal and the self-play is a way of motivating an agent to learn about its environment to augment sparse rewards from separate target tasks.
+
+Our approach has some relationships with generative adversarial networks (GANs) (Goodfellow et al., 2014), which train a generative neural net by having it try to fool a discriminator network which tries to differentiate samples from the training examples. Li et al. (2017) introduce an adversarial approach to dialogue generation, where a generator model is subjected to a form of “Turing test” by a discriminator network. Mescheder et al. (2017) demonstrate how adversarial loss terms can be combined with variational auto-encoders to permit more accurate density modeling. While GAN’s are often thought of as methods for training a generator, the generator can be thought of as a method for generating hard negatives for the discriminator. From this viewpoint, in our approach, Alice acts as a “generator”, finding “negatives” for Bob. However, Bob’s jobs is to complete the generated challenge, not to discriminate it.
+
+There is a large body of work on intrinsic motivation (Barto, 2013; Singh et al., 2004; Klyubin et al., 2005; Schmidhuber, 1991) for self-supervised learning agents. These works propose methods for training an agent to explore and become proficient at manipulating its environment without necessarily having a specific target task, and without a source of extrinsic supervision. One line in this direction is curiosity-driven exploration (Schmidhuber, 1991). These techniques can be applied in encouraging exploration in the context of reinforcement learning, for example (Bellemare et al., 2016; Strehl & Littman, 2008; Lopes et al., 2012; Tang et al., 2016; Pathak et al., 2017); Roughly, these use some notion of the novelty of a state to give a reward. In the simplest setting, novelty can be just the number of times a state has been visited; in more complex scenarios, the agent can build a model of the world, and the novelty is the difficulty in placing the current state into the model. In our work, there is no explicit notion of novelty. Even if Bob has seen a state many times, if he has trouble getting to it, Alice should force him towards that state. Another line of work on intrinsic motivation is a formalization of the notion of empowerment (Klyubin et al., 2005), or how much control the agent has over its environment. Our work is related in the sense that it is in both Alice’s and Bob’s interests to have more control over the environment; but we do not explicitly measure that control except in relation to the tasks that Alice sets.
+
+Curriculum learning (Bengio et al., 2009) is widely used in many machine learning approaches. Typically however, the curriculum requires at least some manual specification. A key point about our work is that Alice and Bob devise their own curriculum entirely automatically. Previous automatic approaches, such as Kumar et al. (2010), rely on monitoring training error. But since ours is unsupervised, no training labels are required either.
+
+Our basic paradigm of “Alice proposing a task, and Bob doing it” is related to the Horde architecture (Sutton et al., 2011) and (Schaul et al., 2015). In those works, instead of using a value function $V = V ( s )$ that depends on the current state, a value function that explicitly depends on state and goal $V = V ( s , g )$ is used. In our experiments, our models will be parameterized in a similar fashion. The novelty in this work is in how Alice defines the goal for Bob.
+
+The closest work to ours is that of Baranes & Oudeyer (2013), who also have one part of the model that proposes tasks, while another part learns to complete them. As in this work, the policies and cost are parameterized as functions of both state and goal. However, our approach differs in the way tasks are proposed and communicated. In particular, in Baranes & Oudeyer (2013), the goal space has to be presented in a way that allows explicit partitioning and sampling, whereas in our work, the goals are sampled through Alice’s actions. On the other hand, we pay for not having to have such a representation by requiring the environment to be either reversible or resettable.
+
+Several concurrent works are related: Andrychowicz et al. (2017) form an implicit curriculum by using internal states as a target. Florensa et al. (2017) automatically generate a series of increasingly distant start states from a goal. Pinto et al. (2017) use an adversarial framework to perturb the environment, inducing improved robustness of the agent. Held et al. (2017) propose a scheme related to our “random Alice” strategy2.
+
+# 4 EXPERIMENTS
+
+The following experiments explore our self-play approach on a variety of tasks, both continuous and discrete, from the Mazebase (Sukhbaatar et al., 2015), RLLab (Duan et al., 2016), and StarCraft (Synnaeve et al., 2016) environments. The same protocol is used in all settings: self-play and target task episodes are mixed together and used to train the agent via discrete policy gradient. We evaluate both the reverse and repeat versions of self-play. We demonstrate that the self-play episodes help training, in terms of number of target task episodes needed to learn the task. Note that we assume the self-play episodes to be “free”, since they make no use of environmental reward. This is consistent with traditional semi-supervised learning, where evaluations typically are based only on the number of labeled points (not unlabeled ones too).
+
+In all the experiments we use policy gradient (Williams, 1992) with a baseline for optimizing the policies. In the tabular task below, we use a constant baseline; in all the other tasks we use a policy parameterized by a neural network, and a baseline that depends on the state. We denote the states in an episode by $s _ { 1 } , . . . , s _ { T }$ , and the actions taken at each of those states as $a _ { 1 } , . . . , a _ { T }$ , where $T$ is the length of the episode. The baseline is a scalar function of the states $b ( s , \theta )$ , computed via an extra head on the network producing the action probabilities. Besides maximizing the expected reward with policy gradient, the models are also trained to minimize the distance between the baseline value and actual reward. Thus after finishing an episode, we update the model parameters $\theta$ by
+
+$$
+\Delta \theta = \sum _ { t = 1 } ^ { T } \left[ \frac { \partial \log f ( a _ { t } | s _ { t } , \theta ) } { \partial \theta } \left( \sum _ { i = t } ^ { T } r _ { i } - b ( s _ { t } , \theta ) \right) - \lambda \frac { \partial } { \partial \theta } \left( \sum _ { i = t } ^ { T } r _ { i } - b ( s _ { t } , \theta ) \right) ^ { 2 } \right] .
+$$
+
+Here $r _ { t }$ is reward given at time $t$ , and the hyperparameter $\lambda$ is for balancing the reward and the baseline objectives, which is set to 0.1 in all experiments.
+
+For the policy neural networks, we use two-layer fully-connected networks with 50 hidden units in each layer. The training uses RMSProp (Tieleman & Hinton, 2012). We always do 10 runs with different random initializations and report their mean and standard deviation. See Appendix $\mathbf { B }$ for all the hyperparameter values used in the experiments.
+
+# 4.1 LONG HALLWAY
+
+We first describe a simple toy environment designed to illustrate the function of the asymmetric selfplay. The environment consists of $M$ states $\{ \bar { s _ { 1 } } , . . . , s _ { M } \}$ arranged in a chain. Both Alice and Bob have three possible actions, “left”, “right”, or “stop”. If the agent is at $s _ { i }$ with $i \neq 1$ , “left” takes it to $s _ { i - 1 }$ ; “right” analogously increases the state index, and “stop” transfers control to Bob when Alice runs it and terminates the episode when Bob runs it. We use “return to initial state” as the self-play task (i.e. Reverse in Algorithm 1 in Appendix A ). For the target task, we randomly pick a starting state and target state, and the episode is considered successful if Bob moves to the target state and executes the stop action before a fixed number of maximum steps.
+
+In this case, the target task is essentially the same as the self-play task, and so running it is not unsupervised learning (and in particular, on this toy example unlike the other examples below, we do not mix self-play training with target task training). However, we see that the curriculum afforded by the self-play is efficient at training the agent to do the target task at the beginning of the training, and is effective at forcing exploration of the state space as Bob gets more competent.
+
+In Fig. 2 (left) we plot the number of episodes vs rate of success at the target task with four different methods. We set $M = 2 5$ and the maximum allowed steps for Alice and Bob to be 30. We use fully tabular controllers; the table is of size $M ^ { 2 } \times 3$ , with a distribution over the three actions for each possible (start, end pair).
+
+The red curve corresponds to policy gradient, with a penalty of $- 1$ given upon failure to complete the task, and a penalty of $- t / t _ { \mathrm { M a x } }$ for successfully completing the task in $t$ steps. The magenta curve corresponds to taking Alice to have a random policy $( 1 / 2$ probability of moving left or right, and not stopping till the maximum allowed steps). The green curve corresponds to policy gradient with an exploration bonus similar to Strehl & Littman (2008). That is, we keep count of the number of times√ $N _ { s }$ the agent has been in each state $s$ , and the reward for $s$ is adjusted by exploration bonus $\alpha / \sqrt { N _ { s } }$ , where $\alpha$ is a constant balancing the reward from completing the task with the exploration bonus. We choose the weight $\alpha$ to maximize success at $\phantom { - } 0 . 2 \mathbf { M }$ episodes from the set $\{ 0 , 0 . 1 , 0 . 2 , . . . , 1 \}$ . The blue curve corresponds to the asymmetric self-play training.
+
+We can see that at the very beginning, a random policy for Alice gives some form of curriculum but eventually is harmful, because Bob never gets to see any long treks. On the other hand, policy gradient sees very few successes in the beginning, and so trains slowly. Using the self-play method, Alice gives Bob easy problems at first (she starts from random), and then builds harder and harder problems as the training progresses, finally matching the performance boost of the count based exploration. Although not shown, similar patterns are observed for a wide range of learning rates.
+
+# 4.2 MAZEBASE: LIGHT KEY
+
+We now describe experiments using the MazeBase environment (Sukhbaatar et al., 2015), which have discrete actions and states, but sufficient combinatorial complexity that tabular methods cannot be used. The environment consist of various items placed on a finite 2D grid; and randomly generated for each episode.
+
+We use an environment where the maze contains a light switch (whose initial state is sampled according to a predefined probability, p(Light off)), a key and a wall with a door (see Fig. 1). An agent can open or close the door by toggling the key switch, and turn on or off light with the light switch. When the light is off, the agent can only see the (glowing) light switch. In the target task, there is also a goal flag item, and the objective of the game is reach to that goal flag.
+
+In self-play, the environment is the same except there is no specific objective. An episode starts with Alice in control, who can navigate through the maze and change the switch states until she outputs the STOP action. Then, Bob takes control and tries to return everything to its original state (restricted to visible items) in the reverse self-play. In the repeat version, the maze resets back to its initial state when Bob takes the control, who tries to reach the final state of Alice.
+
+In Fig. 2 (right), we set p(Light off) $= 0 . 5$ during self-play3 and evaluate the repeat form of self-play, alongside two baselines: (i) target task only training (i.e. no self-play) and (ii) self-play with a random policy for Alice. With self-play, the agent succeeds quickly while target task-only training takes much longer4. Fig. 3 shows details of a single training run, demonstrating how Alice and Bob automatically build a curriculum between themselves though self-play.
+
+# 4.3 RLLAB: MOUNTAIN CAR
+
+We applied our approach to the Mountain Car task in RLLab. Here the agent controls a car trapped in a 1-D valley. It must learn to build momentum by alternately moving to the left and right, climbing higher up the valley walls until it is able to escape. Although the problem is presented as continuous, we discretize the 1-D action space into 5 bins (uniformly sized) enabling us to use discrete policy gradient, as above. We also added a secondary action head with binary actions to be used as STOP action. An observation of state $s _ { t }$ consists of the location and speed of the car.
+
+As in Houthooft et al. (2016); Tang et al. (2016), a reward of $+ 1$ is given only when the car succeeds in climbing the hill. In self-play, Bob succeeds if $\| s _ { b } - s _ { a } \| < 0 . 2$ , where $s _ { a }$ and $s _ { b }$ are the final states (location and velocity of the car) of Alice and Bob respectively.
+
+The nature of the environment makes it highly asymmetric from Alice and Bob’s point of view, since it is far easier to coast down the hill to the starting point that it is to climb up it. Hence we exclusively use the reset form of self-play. In Fig. 4 (left), we compare this to current state-of-the-art methods, namely VIME (Houthooft et al., 2016) and SimHash (Tang et al., 2016). Our approach (blue) performs comparably to both of these. We also tried using policy gradient directly on the target task samples, but it was unable to solve the problem.
+
+![](images/fd97037d7dfd8b0c298fff0cc2c18d95ac0f656b56a8068fb1ee8e614ef71d71.jpg)  
+Figure 2: Left: The hallway task from section 4.1. The $y$ axis is fraction of successes on the target task, and the $x$ axis is the total number of training examples seen. Standard policy gradient (red) learns slowly. Adding an explicit exploration bonus (Strehl & Littman, 2008) (green) helps significantly. Our self-play approach (blue) gives similar performance however. Using a random policy for Alice (magenta) drastically impairs performance, showing the importance of self-play between Alice and Bob. Right: Mazebase task, illustrated in Fig. 1, for p(Light off) $= 0 . 5$ . Augmenting with the repeat form of self-play enables significantly faster learning than training on the target task alone and random Alice baselines.
+
+![](images/f5ed4f61d0e7add8c1f00c093478873a71cfc2e186ade55e93fc03d269aa09ed.jpg)  
+Figure 3: Inspection of a Mazebase learning run, using the environment shown in Fig. 1. (a): rate at which Alice interacts with 1, 2 or 3 objects during an episode, illustrating the automatically generated curriculum. Initially Alice touches no objects, but then starts to interact with one. But this rate drops as Alice devises tasks that involve two and subsequently three objects. (b) by contrast, in the random Alice baseline, she never utilizes more than a single object and even then at a much lower rate. (c) plot of Alice and Bob’s reward, which strongly correlates with (a). (d) plot of $t _ { a }$ as self-play progresses. Alice takes an increasing amount of time before handing over to Bob, consistent with tasks of increasing difficulty being set.
+
+# 4.4 RLLAB: SWIMMERGATHER
+
+We also applied our approach to the SwimmerGather task in RLLab (which uses the Mujoco (Todorov et al., 2012) simulator), where the agent controls a worm with two flexible joints, swimming in a 2D viscous fluid. In the target task, the agent gets reward $+ 1$ for eating green apples and -1 for touching red bombs, which are not present during self-play. Thus the self-play task and target tasks are different: in the former, the worm just swims around but in the latter it must learn to swim towards green apples and away from the red bombs.
+
+The observation state consists of a 13-dimensional vector describing location and joint angles of the worm, and a 20 dimensional vector for sensing nearby objects. The worm takes two real values as an action, each controlling one joint. We add a secondary action head to our models to handle the 2nd joint, and a third binary action head for STOP action. As in the mountain car, we discretize the output space (each joint is given 9 uniformly sized bins) to allow the use of discrete policy gradients.
+
+Bob succeeds in a self-play episode when $\| l _ { b } - l _ { a } \| < 0 . 3$ where $l _ { a }$ and $l _ { b }$ are the final locations of Alice and Bob respectively. Fig. 4 (right) shows the target task reward as a function of training iteration for our approach alongside state-of-the-art exploration methods VIME (Houthooft et al., 2016) and SimHash (Tang et al., 2016). We demonstrate the generality of the self-play approach by applying it to Reinforce and also TRPO (Schulman et al., 2015) (see Appendix D for details). In both cases, it enables them to gain reward significantly earlier than other methods, although both converge to a similar final value to SimHash. A video of our worm performing the test task can be found at https://goo.gl/Vsd8Js.
+
+![](images/7bc22b89f7cabb0fb8047c902b16342f1019591342f2ef3dd6922a1ef4dc3629.jpg)  
+Figure 4: Evaluation on MountainCar (left) and SwimmerGather (right) target tasks, comparing to VIME Houthooft et al. (2016) and SimHash Tang et al. (2016) (figures adapted from Tang et al. (2016)). With reversible self-play we are able to learn faster than the other approaches, although it converges to a comparable reward. Training directly on the target task using Reinforce without self-play resulted in total failure. Here 1 iteration $= 5 \mathrm { k }$ (50k) target task steps in Mountain car (SwimmerGather), excluding self-play steps.
+
+# 4.5 STARCRAFT: TRAINING MARINES
+
+Finally, we applied our self-play approach to the same setup as the beginning of a standard StarCraft: Brood War game Synnaeve et al. (2016), where an agent controls multiple units to mine, construct buildings, and train new units, but without enemies to fight. The environment starts with 4 workers units (Terran SCVs), who can move around, mine nearby minerals and construct new buildings. In addition, the agent controls the command center, which can train new workers. See Fig. 5 (left) for relations between different units and their actions.
+
+The target task is to build Marine units. To do this, an agent must follow a specific sequence of operations: (i) mine minerals with workers; (ii) having accumulated sufficient mineral supply, build a barracks and (iii) once the barracks are complete, train Marine units out of it. Optionally, an agent can train a new worker for faster mining, or build a supply depot to accommodate more units. When the episode ends after 200 steps (little over 3 minutes), the agent gets rewarded $+ 1$ for each Marine it has built. Optimizing this task is highly complex due to several factors. First, the agent has to find an optimal mining pattern (concentrating on a single mineral or mining a far away mineral is inefficient). Then, it has to produce the optimal number of workers and barrack at the right timing. In addition, a supply depot needs to be built when the number of units is close to the limit.
+
+During self-play (repeat variant), Alice and Bob control the workers and can try any combination of actions during the episode. Since exactly matching the game state is almost impossible, Bob’s success is only based on the global state of the game, which includes the number of units of each type (including buildings), and accumulated mineral resource. So Bob’s objective in self-play is to make as many units and mineral as Alice in shortest possible time. Further details are given in Appendix E. Fig. 5 (right) compares the Reinforce algorithm on the target task, with and without self-play. An additional count-based exploration baseline similar to the hallway experiment is also shown. It utilizes the same global game state as self-play.
+
+# 5 DISCUSSION
+
+In this work we described a novel method for intrinsically motivated learning which we call asymmetric self-play. Despite the method’s conceptual simplicity, we have seen that it can be effective in both discrete and continuous input settings with function approximation, for encouraging exploration and automatically generating curriculums. On the challenging benchmarks we consider, our approach is at least as good as state-of-the-art RL methods that incorporate an incentive for exploration, despite being based on very different principles. Furthermore, it is possible show theoretically that in simple environments, using asymmetric self-play with reward functions from (1) and (2), optimal agents can transit between any pair of reachable states as efficiently as possible. Code for our approach can be found at (link removed for anonymity).
+
+![](images/9d740b096917a0ed320f9d5dee4a1dea5a4333c2557c3fc29fe88147178a37a1.jpg)  
+Figure 5: Left: Different types of unit in the StarCraft environment. The arrows represent possible actions (excluding movement actions) by the unit, and corresponding numbers shows (blue) amount of minerals and (red) time steps needed to complete. The units under agent’s control are outlined by a green border. Right: Plot of reward on the StarCraft sub-task of training marine units vs #target-task episodes (self-play episodes are not included), with and without self-play. A count-based baseline is also shown. Self-play greatly speeds up learning, and also surpasses the count-based approach at convergence.
+
+# REFERENCES
+
+Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. CoRR, abs/1707.01495, 2017. URL http://arxiv.org/abs/1707.01495.
+
+A. Baranes and P-Y. Oudeyer. Active learning of inverse models with intrinsically motivated goal exploration in robots. Robotics and Autonomous Systems, 61(1):49–73, 2013.
+
+Andrew G. Barto. Intrinsic Motivation and Reinforcement Learning, pp. 17–47. Springer Berlin Heidelberg, 2013.
+
+Marc G. Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi´ Munos. Unifying count-based exploration and intrinsic motivation. In NIPS, pp. 1471–1479, 2016.
+
+Yoshua Bengio, Jer´ ome Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In ˆ ICML, pp. 41–48, 2009.
+
+Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continuous control. In ICML, 2016.
+
+Carlos Florensa, David Held, Markus Wulfmeier, and Pieter Abbeel. Reverse curriculum generation for reinforcement learning. CoRR, abs/1707.05300, 2017. URL http://arxiv.org/abs/ 1707.05300.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, pp. 2672–2680, 2014.
+
+David Held, Xinyang Geng, Carlos Florensa, and Pieter Abbeel. Automatic goal generation for reinforcement learning agents. CoRR, abs/1705.06366, 2017. URL http://arxiv.org/ abs/1705.06366.
+
+Rein Houthooft, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel. Curiosity-driven exploration in deep reinforcement learning via bayesian neural networks. arXiv 1605.09674, 2016.
+
+Alexander S. Klyubin, Daniel Polani, and Chrystopher L. Nehaniv. Empowerment: a universal agent-centric measure of control. In Proceedings of the IEEE Congress on Evolutionary Computation, CEC, pp. 128–135, 2005.
+
+M. P. Kumar, Benjamin Packer, and Daphne Koller. Self-paced learning for latent variable models. In NIPS. 2010.
+
+Jiwei Li, Will Monroe, Tianlin Shi, Alan Ritter, and Dan Jurafsky. Adversarial learning for neural dialogue generation. arXiv 1701.06547, 2017.
+
+Manuel Lopes, Tobias Lang, Marc Toussaint, and Pierre-Yves Oudeyer. Exploration in model-based reinforcement learning by empirically estimating learning progress. In NIPS, pp. 206–214, 2012.
+
+Lars M. Mescheder, Sebastian Nowozin, and Andreas Geiger. Adversarial variational bayes: Unifying variational autoencoders and generative adversarial networks. arXiv abs/1701.04722, 2017.
+
+Deepak Pathak, Pulkit Agrawal, Alexei A. Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In ICML, 2017.
+
+Lerrel Pinto, James Davidson, Rahul Sukthankar, and Abhinav Gupta. Robust adversarial reinforcement learning. CoRR, abs/1703.02702, 2017. URL http://arxiv.org/abs/1703. 02702.
+
+Martin Riedmiller, Thomas Gabel, Roland Hafner, and Sascha Lange. Reinforcement learning for robot soccer. Autonomous Robots, 27(1):55–73, 2009.
+
+Arthur L. Samuel. Some studies in machine learning using the game of checkers. IBM Journal of Research and Development, 3(3):210–229, 1959.
+
+Tom Schaul, Dan Horgan, Karol Gregor, and David Silver. Universal value function approximators. In ICML, pp. 1312–1320, 2015.
+
+J. Schmidhuber. Curious model-building control systems. In Proc. Int. J. Conf. Neural Networks, pp. 1458–1463. IEEE Press, 1991.
+
+John Schulman, Sergey Levine, Philipp Moritz, Michael I. Jordan, and Pieter Abbeel. Trust region policy optimization. arXiv1502.05477, 2015.
+
+David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, Sander Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy Lillicrap, Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of Go with deep neural networks and tree search. Nature, 529(7587):484–489, January 2016.
+
+Satinder P. Singh, Andrew G. Barto, and Nuttapong Chentanez. Intrinsically motivated reinforcement learning. In NIPS, pp. 1281–1288, 2004.
+
+Alexander L. Strehl and Michael L. Littman. An analysis of model-based interval estimation for markov decision processes. J. Comput. Syst. Sci., 74(8):1309–1331, 2008.
+
+Sainbayar Sukhbaatar, Arthur Szlam, Gabriel Synnaeve, Soumith Chintala, and Rob Fergus. Mazebase: A sandbox for learning from games. arXiv 1511.07401, 2015.
+
+Richard S. Sutton, Joseph Modayil, Michael Delp, Thomas Degris, Patrick M. Pilarski, Adam White, and Doina Precup. Horde: A scalable real-time architecture for learning knowledge from unsupervised sensorimotor interaction. In AAMAS ’11, pp. 761–768, 2011.
+
+Gabriel Synnaeve, Nantas Nardelli, Alex Auvolat, Soumith Chintala, Timothee Lacroix, Zeming ´ Lin, Florian Richoux, and Nicolas Usunier. Torchcraft: a library for machine learning research on real-time strategy games. arXiv preprint arXiv:1611.00625, 2016.
+
+H. Tang, R. Houthooft, D. Foote, A. Stooke, X. Chen, Y. Duan, J. Schulman, F. De Turck, and P. Abbeel. #exploration: A study of count-based exploration for deep reinforcement learning. arXiv abs/1611.04717, 2016.
+
+Gerald Tesauro. Temporal difference learning and td-gammon. Commun. ACM, 38(3):58–68, 1995.
+
+T. Tieleman and G. Hinton. Lecture 6.5 - rmsprop, coursera: Neural networks for machine learning, 2012.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In IROS, pp. 5026–5033. IEEE, 2012.
+
+Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. In Machine Learning, pp. 229–256, 1992.
+
+# A PSEUDO CODE
+
+Algorithm 1 and 2 are the pseudo codes for training an agent on self-play and target task episodes.
+
+# Algorithm 1 Pseudo code for training an agent on a self-play episode
+
+<table><tr><td>function SELFPLAYEPISODE(REVERSE/REPEAT,tMAx,0A,0B)</td></tr><tr><td>tA↑0 So←env.observe()</td></tr><tr><td>S* ↑</td></tr><tr><td>while True do</td></tr><tr><td># Alice&#x27;s turn</td></tr><tr><td>tA←tA+1</td></tr><tr><td>s ← env.observe()</td></tr><tr><td>a←πA(s,so)=f(s,So,0A)</td></tr><tr><td>if α = STOP or tA ≥ tMax then</td></tr><tr><td>s*↑s env.reset()</td></tr><tr><td>break</td></tr><tr><td>env.act(a)</td></tr><tr><td>tb↑0</td></tr><tr><td>while True do</td></tr><tr><td>#Bob&#x27;s turn</td></tr><tr><td>s← env.observe()</td></tr><tr><td>if s= s*or tA+tb≥tMax then</td></tr><tr><td>break</td></tr><tr><td>tb←tb+1</td></tr><tr><td>a←TB(s,s*)=f(s,s*,0B)</td></tr><tr><td>env.act(a)</td></tr><tr><td>RA←γmax(O,tB-tA)</td></tr><tr><td>RB←-γtB</td></tr><tr><td></td></tr><tr><td>policy.update(RA, 0A)</td></tr><tr><td>policy.update(RB,0B)</td></tr><tr><td>return</td></tr></table>
+
+# B HYPERPARAMETERS USED IN THE EXPERIMENTS
+
+For the experiments with neural networks, all parameters are randomly initialized from $\mathcal { N } ( 0 , 0 . 2 )$ . The Hyperparameters of RMSProp are set to 0.97 and $1 e - 6$ . The other hyperparameter values used in the experiments are shown in Table 1. In some cases, we used different parameters for self-play and target task episodes. Entropy regularization is implemented as an additional cost maximizing the entropy of the softmax layer. In the StarCraft, skipping 23 frames roughly matches to one action per second.
+
+# Algorithm 2 Pseudo code for training an agent on a target task episode
+
+function TARGETTASKEPISODE(tMAX, θB) t ← 0 R ← 0 while True do $t \gets t + 1$ $s $ env.observe() $a  \pi _ { B } ( s , \emptyset ) = f ( s , \emptyset , \theta _ { B } )$ if env.done() or $t \geq t _ { \mathrm { M a x } }$ then break env.act(a) $R = R +$ env.reward() policy.update $( R , \theta _ { B } )$ return
+
+Table 1: Hyperparameter values used in experiments. $\mathrm { T T } { = }$ target task, $\mathrm { S P = }$ self-play   
+
+<table><tr><td rowspan=1 colspan=1>Hyperparametername</td><td rowspan=1 colspan=1>LongHallway</td><td rowspan=1 colspan=1>Mazebase</td><td rowspan=1 colspan=1>MountainCar</td><td rowspan=1 colspan=1>SwimmerGather</td><td rowspan=1 colspan=1>StarCraft</td></tr><tr><td rowspan=1 colspan=1>Learning rate</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.003</td><td rowspan=1 colspan=1>0.003</td><td rowspan=1 colspan=1>0.003</td><td rowspan=1 colspan=1>0.003</td></tr><tr><td rowspan=1 colspan=1>Batch size</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>32</td></tr><tr><td rowspan=1 colspan=1>Max steps ofepisode (tmax)</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>500</td><td rowspan=1 colspan=1>TT: 166SP: 200</td><td rowspan=1 colspan=1>200</td></tr><tr><td rowspan=1 colspan=1>Entropyregularization</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.003</td><td rowspan=1 colspan=1>0.003</td><td rowspan=1 colspan=1>TT: 0SP: 0.003</td><td rowspan=1 colspan=1>TT: 0SP: 0.003</td></tr><tr><td rowspan=1 colspan=1>Self-play reward scale (γ)</td><td rowspan=1 colspan=1>0.033</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.01</td></tr><tr><td rowspan=1 colspan=1>Self-play percentage</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>20%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>10%</td><td rowspan=1 colspan=1>10%</td></tr><tr><td rowspan=1 colspan=1>Self-play mode</td><td rowspan=1 colspan=1>Reverse</td><td rowspan=1 colspan=1>Both</td><td rowspan=1 colspan=1>Repeat</td><td rowspan=1 colspan=1>Reverse</td><td rowspan=1 colspan=1>Repeat</td></tr><tr><td rowspan=1 colspan=1>Frame skip</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1505</td><td rowspan=1 colspan=1>23</td></tr></table>
+
+# C MAZEBASE
+
+The agent has full visibility of the maze when the light is on. If light is off, the agent can only see the light switch. In self-play, Bob does not need to worry about things that are invisible to him. For example, if Alice started with light “off” in reverse self-play, Bob does not need to match the state of the door, because it would be invisible to him when the light is off.
+
+In the target task, the agent and the goal are always placed on opposite sides of the wall. Also, the light and key switches are placed on the same side as the agent, but the light is always off and the door is closed initially. Therefore, in order to succeed, the agent has to turn on the light, toggle the key switch to open the door, pass through it, and reach the goal flag.
+
+Both Alice and Bob’s policies are modeled by a fully-connected neural network with two hidden layers each with 100 and 50 units (with tanh non-linearities) respectively. The encoder into each of the networks takes a bag of words over (objects, locations); that is, there is a separate word in the lookup table for each (object, location) pair. Action probabilities are output by a linear layer followed by a softmax.
+
+# C.1 BIASING FOR OR AGAINST SELF-PLAY
+
+The effectiveness of our approach depends in part on the similarity between the self-play and target tasks. One way to explore this in our environment is to vary the probability of the light being off initially during self-play episodes6. Note that the light is always off in the target task; if the light is usually on at the start of Alice’s turn in reverse, for example, she will learn to turn it off, and then Bob will be biased to turn it back on. On the other hand, if the light is usually off at the start of Alice’s turn in reverse, Bob is strongly biased against turning the light on, and so the test task becomes especially hard. Thus changing this probability gives us some way to adjust the similarity between the two tasks.
+
+Fig. 6 (left) shows what happens when p(Light off) $\scriptstyle 1 = 0 . 3$ . Here reverse self-play works well, but repeat self-play does poorly. As discussed above, this flipping, relative to the previous experiment, can be explained as follows: low p(Light off) means that Bob’s task in reverse self-play will typically involve returning the light to the on position (irrespective of how Alice left it), the same function that must be performed in the target task. The opposite situation applies for repeat self-play, where Bob needs to encounter the light typically in the off position to help him with the test task.
+
+In Fig. 6 (right) we systematically vary p(Light off) between 0.1 and 0.9. The y-axis shows the speed-up (reduction in target task episodes) relative to training purely on the target-task for runs where the reward goes above -2. Unsuccessful runs are given a unity speed-up factor. The curves show that when the self-play task is not biased against the target task it can help significantly.
+
+![](images/9dea24e2b8a3722d9cd26042796350f4c072933e9ae2a56930497eb412a13080.jpg)  
+Figure 6: Left: The performance of self-play when p(Light off) set to 0.3. Here the reverse form of self-play works well (more details in the text). Right: Reduction in target task episodes relative to training purely on the target-task as the distance between self-play and the target task varies (for runs where the reward goes above -2 on the Mazebase task – unsuccessful runs are given a unity speed-up factor). The $y$ axis is the speedup, and $x$ axis is p(Light off). For reverse self-play, the low p(Light off) corresponds to having self-play and target tasks be similar to one another, while the opposite applies to repeat self-play. For both forms, significant speedups are achieved when self-play is similar to the target tasks, but the effect diminishes when self-play is biased against the target task.
+
+# D SWIMMERGATHER EXPERIMENT
+
+In Fig. 7 shows details of a single training run. The changes in Alice’s behavior, observed in Fig. 7(c) and (d), correlate with Alice and Bob’s reward (Fig. 7(b)) and, initially at least, to the reward on the test target (Fig. 7(a)). In Fig. 8 we visualize for a single training run the locations where Alice hands over to Bob at different stages of training, showing how the distribution varies.
+
+![](images/b10cab091594486bf3cd8e30bf5f5e097c7495e15a6c3fc55af13e6bba396f50.jpg)  
+Figure 7: A single SwimmerGather training run. (a): Rewards on target task. (b): Rewards from reversible self-play. (c): The number of actions taken by Alice. (d): Distance that Alice travels before switching to Bob.
+
+In the TRPO experiment, we used step size 0.01 and damping coefficient 0.1. The batch consists of 50,000 steps, of which $2 5 \%$ comes from target task episodes, while the remaining $7 5 \%$ is from self-play. The self-play reward scale $\gamma$ set to 0.005. We used two separate network for actor and critic, and the critic network has L2 weight regularization with coefficient of $1 e - 5$ .
+
+![](images/b209fac1472f9619db92043d1ca7cfb06e742f027316975d973929360291b5f7.jpg)  
+Figure 8: Plot of Alice’s location at time of STOP action for the SwimmerGather training run shown in Fig. 7, for different stages of training. Note how Alice’s distribution changes as Bob learns to solve her tasks.
+
+# E STARCRAFT EXPERIMENT
+
+We call units that perform action as active unit. This includes worker units (SCVs), the command center, and barrack. The agent controls multiple active units in parallel. At each time step, an action of $\because$ ’th unit is output by
+
+$$
+a _ { t } ^ { i } = \pi ( s _ { t } ^ { i } , { \hat { s } } _ { t } ) ,
+$$
+
+where $s _ { t } ^ { i }$ is a unit specific local observation, and $\hat { s } _ { t }$ is an global observation. With $s _ { t } ^ { i }$ , a unit can see the $6 4 \mathrm { x } 6 4$ area around it with a resolution of 4 (unit’s type is also visible). The global observation contains the number of units and accumulated minerals in the game
+
+$$
+\hat { s } _ { t } = \{ \lfloor N _ { \mathrm { o r e } } / 2 5 \rfloor , N _ { \mathrm { S C V } } , N _ { \mathrm { B a r r a c k } } , N _ { \mathrm { S u p p l y D e p o t } } , N _ { \mathrm { M a r i n e s } } \} .
+$$
+
+In self-play, Bob perceives only the global observation of his target state
+
+$$
+\pi _ { B } \big ( s _ { t } ^ { i } , \hat { s } _ { t } , \hat { s } ^ { * } \big ) ,
+$$
+
+where $\hat { s } ^ { * }$ is the final global observation of Alice. Bob will succeed only if
+
+$$
+\begin{array} { r l } { \forall i } & { { } \hat { s } _ { t } [ i ] \geq \hat { s } ^ { * } [ i ] . } \end{array}
+$$
+
+Table 2 shows the action space of different unit types controlled by the agent. The number of possible action is the same for all units since they controlled by a single model (unit type is encoded in the observation), but the meaning of actions differ according to unit type. An empty cell mean that the unit does nothing (nothing is sent to StarCraft, so the previous action persists).
+
+The more complexes actions “mine minerals”, “build a barracks”, “build a supply depot” have the following semantics, respectively: mine the mineral closest to the current unit, build a barracks at the position of the current unit, build a supply depot on the position of the current unit.
+
+Some actions are ignored under certain conditions: “mining” action is ignored if the distance to the closest mineral is greater than 12; “switch to Bob” is ignored if Bob is already in control; “building” and “training” actions are ignored if there is not enough resources; the actions that create a new SCV or a barracks are ignored if the number of active units is reached the limit of 10. Also “build” actions will be ignored if there is not enough room to build at the unit’s location.
+
+For the count-based exploration, we gave an extra reward of $\alpha / \sqrt { N ( \hat { s _ { t } } ) }$ at every step, where $N$ is the visit count function and $\hat { s _ { t } }$ is a global observation. We found $\alpha = 0 . 1$ to be works the best.
+
+In Fig. 9 we show the result of an additional experiment where we extended the length of the episode from 200 to 300, giving more time to the agent for development. The self-play still outperforms baselines methods. Note that to make more than 6 marines, an agent has to build a supply depot as well as a barracks.
+
+Table 2: Action space of different unit types in StarCraft.   
+
+<table><tr><td rowspan=1 colspan=1>Action ID</td><td rowspan=1 colspan=1>SCV</td><td rowspan=1 colspan=1>Command center</td><td rowspan=1 colspan=1>Barraks</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>move to right</td><td rowspan=1 colspan=1>train SCV</td><td rowspan=1 colspan=1>trainamarine</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>move to left</td><td rowspan=1 colspan=1>switch to Bob</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>move to top</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>move to bottom</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>mine minerals</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>build a barracks</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>build a supply depot</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr></table>
+
+![](images/c530d592ad4225a204dc121b42651ffab7d714d60c8b59ff42a8c8e545970c76.jpg)  
+Figure 9: Plot of reward on the StarCraft sub-task of training where episode length $t _ { \mathrm { M a x } }$ is increased to 300.
+
+# F FURTHER DISCUSSION
+
+# F.1 META-EXPLORATION FOR ALICE
+
+We want Alice and Bob to explore the state (or state-action) space, and we would like Bob to be exposed to many different tasks. Because of the form of the standard reinforcement learning objective (expectation over rewards), Alice only wants to find the single hardest thing for Bob, and is not interested in the space of things that are hard for Bob. In the fully tabular setting, with fully reversible dynamics or with resetting, and without the constraints of realistic optimization strategies, we saw in section 2.2 that this ends up forcing Bob and Alice to learn to make any state transition as efficiently as possible. However, with more realistic optimization methods or environments, and with function approximation, Bob and Alice can get stuck in sub-optimal minima.
+
+For example, let us follow the argument in the third paragraph of Sec. 2.2, and assume that Bob and Alice are at an equilibrium (and that we are in the tabular, finite, Markovian setting), but now we can only update Bob’s and Alice’s policy locally. By this we mean that in our search for a better policy for Bob or Alice, we can only make small perturbations, as in policy gradient algorithms. In this case, we can only guarantee that Bob runs a fast policy on challenges that Alice has non-zero probability of giving; but there is no guarantee that Alice will cover all possible challenges. With function approximation instead of tabular policies, we cannot make any guarantees at all.
+
+Another example with a similar outcome but different mechanism can occur using the reverse game in an environment without fully reversible dynamics. In that case, it could be that the shortest expected number of steps to complete a challenge $\left( { { s } _ { 0 } } , { { s } _ { T } } \right)$ is longer than the reverse, and indeed, so much longer that Alice should concentrate all her energy on this challenge to maximize her rewards. Thus there could be equilibria with Bob matching the fast policy only for a subset of challenges even if we allow non-local optimization.
+
+The result is that Alice can end up in a policy that is not ideal for our purposes. In figure 8 we show the distributions of where Alice cedes control to Bob in the swimmer task. We can see that Alice has a preferred direction. Ideally, in this environment, Alice would be teaching Bob how to get from any state to any other efficiently; but instead, she is mostly teaching him how to move in one direction.
+
+One possible approach to correcting this is to have multiple Alices, regularized so that they do not implement the same policy. More generally, we can investigate objectives for Alice that encourage her to cover a wider distribution of behaviors.
+
+# F.2 COMMUNICATING VIA ACTIONS
+
+In this work we have limited Alice to propose tasks for Bob by doing them. This limitation is practical and effective in restricted environments that allow resetting or are (nearly) reversible. It allows a solution to three of the key difficulties of implementing the basic idea of “Alice proposes tasks, Bob does them”: parameterizing the sampling of tasks, representing and communicating the tasks, and ensuring the appropriate level of difficulty of the tasks. Each of these is interesting in more general contexts. In this work, the tasks have incentivized efficient transitions. One can imagine other reward functions and task representations that incentivize discovering statistics of the states and state-transitions, for example models of their causality or temporal ordering, cluster structure.

parse/train/SkT5Yg-RZ/SkT5Yg-RZ_content_list.json

@@ -0,0 +1,1994 @@
+[
+    {
+        "type": "text",
+        "text": "INTRINSIC MOTIVATION AND AUTOMATICCURRICULA VIA ASYMMETRIC SELF-PLAY",
+        "text_level": 1,
+        "bbox": [
+            173,
+            99,
+            687,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar Dept. of Computer Science New York University sainbar@cs.nyu.edu ",
+        "bbox": [
+            183,
+            170,
+            364,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zeming Lin   \nFacebook AI Research   \nNew York   \nzlin@fb.com ",
+        "bbox": [
+            415,
+            170,
+            565,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ilya Kostrikov Dept. of Computer Science New York University kostrikov@cs.nyu.edu ",
+        "bbox": [
+            614,
+            171,
+            813,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Synnaeve, Arthur Szlam & Rob Fergus ",
+        "text_level": 1,
+        "bbox": [
+            186,
+            247,
+            516,
+            261
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Facebook AI Research   \nNew York   \n{gab,aszlam,robfergus}@fb.com ",
+        "bbox": [
+            184,
+            263,
+            467,
+            304
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            340,
+            544,
+            354
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We describe a simple scheme that allows an agent to learn about its environment in an unsupervised manner. Our scheme pits two versions of the same agent, Alice and Bob, against one another. Alice proposes a task for Bob to complete; and then Bob attempts to complete the task. In this work we will focus on two kinds of environments: (nearly) reversible environments and environments that can be reset. Alice will “propose” the task by doing a sequence of actions and then Bob must undo or repeat them, respectively. Via an appropriate reward structure, Alice and Bob automatically generate a curriculum of exploration, enabling unsupervised training of the agent. When Bob is deployed on an RL task within the environment, this unsupervised training reduces the number of supervised episodes needed to learn, and in some cases converges to a higher reward. ",
+        "bbox": [
+            233,
+            371,
+            764,
+            523
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            551,
+            336,
+            568
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Model-free approaches to reinforcement learning are sample inefficient, typically requiring a huge number of episodes to learn a satisfactory policy. The lack of an explicit environment model means the agent must learn the rules of the environment from scratch at the same time as it tries to understand which trajectories lead to rewards. In environments where reward is sparse, only a small fraction of the agents’ experience is directly used to update the policy, contributing to the inefficiency. ",
+        "bbox": [
+            174,
+            583,
+            823,
+            667
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper we introduce a novel form of unsupervised training for an agent that enables exploration and learning about the environment without any external reward that incentivizes the agents to learn how to transition between states as efficiently as possible. We demonstrate that this unsupervised training allows the agent to learn new tasks within the environment quickly. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            729
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 APPROACH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            750,
+            299,
+            766
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We consider environments with a single physical agent (or multiple physical units controlled by a single agent), but we allow it to have two separate “minds”: Alice and Bob, each with its own objective and parameters. During self-play episodes, Alice’s job is to propose a task for Bob to complete, and Bob’s job is to complete the task. When presented with a target task episode, Bob is then used to perform it (Alice plays no role). The key idea is that the Bob’s play with Alice should help him understand how the environment works and enabling him to learn the target task more quickly. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our approach is restricted to two classes of environment: (i) those that are (nearly) reversible, or (ii) ones that can be reset to their initial state (at least once). These restrictions allow us to sidestep complications around how to communicate the task and determine its difficulty (see Appendix F.2 for further discussion). In these two scenarios, Alice starts at some initial state $s _ { 0 }$ and proposes a task by doing it, i.e. executing a sequence of actions that takes the agent to a state $s _ { t }$ . She then outputs a STOP action, which hands control over to Bob. In reversible environments, Bob’s goal is to return the agent back to state $s _ { 0 }$ (or within some margin of it, if the state is continuous), to receive reward. In partially observable environments, the objective is relaxed to Bob finding a state that returns the same observation as Alice’s initial state. In environments where resets are permissible, Alice’s STOP action also reinitializes the environment, thus Bob starts at $s _ { 0 }$ and now must reach $s _ { t }$ to be rewarded, thus repeating Alice’s task instead of reversing it. See Fig. 1 for an example, and also Algorithm 1 in Appendix A. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/7a0fb69b8512612d2b8fa5d73a06dd1b5ae9373c04f571492ab24b6a8c9031ad.jpg",
+        "image_caption": [
+            "Bob\tapplied\tto\ttarget\ttask "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            607,
+            99,
+            782,
+            220
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/77c7cd4ceefc87391c2fd192d27a67f27251053c83d29d18dc2e3330d52f342f.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of the self-play concept in a gridworld setting. Training consists of two types of episode: self-play and target task. In the former, Alice and Bob take turns moving the agent within the environment. Alice sets tasks by altering the state via interaction with its objects (key, door, light) and then hands control over to Bob. He must return the environment to its original state to receive an internal reward. This task is just one of many devised by Alice, who automatically builds a curriculum of increasingly challenging tasks. In the target task, Bob’s policy is used to control the agent, with him receiving an external reward if he visits the flag. He is able to learn to do this quickly as he is already familiar with the environment from self-play. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            101,
+            581,
+            231
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            382,
+            825,
+            508
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In both cases, this self-play between Alice and Bob only involves internal reward (detailed below), thus the agent can be trained without needing any supervisory signal from the environment. As such, it comprises a form of unsupervised training where Alice and Bob explore the environment and learn how it operates. This exploration can be leveraged for some target task by training Bob on target task episodes in parallel. The idea is that Bob’s experience from self-play will help him learn the target task in fewer episodes. The reason behind choosing Bob for the target task is because he learns to transfer from one state to another efficiently from self-play. See Algorithm 2 in Appendix A for detail. ",
+        "bbox": [
+            173,
+            515,
+            825,
+            627
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For self-play, we choose the reward structure for Alice and Bob to encourage Alice to push Bob past his comfort zone, but not give him impossible tasks. Denoting Bob’s total reward by $R _ { B }$ (given at the end of episodes) and Alice’s total reward by $R _ { A }$ , we use ",
+        "bbox": [
+            174,
+            633,
+            825,
+            676
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/82f26d450436f47e2cfc2a1e7bc1d3574f51ebb67f307f2ccfc6734ae342843d.jpg",
+        "text": "$$\nR _ { B } = - \\gamma t _ { B }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            454,
+            689,
+            544,
+            705
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $t _ { B }$ is the time taken by Bob to complete his task and ",
+        "bbox": [
+            173,
+            719,
+            563,
+            734
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8f299b9b9d20e07603d541cd78bc39e3ba805b17de6825d2994dfeb824281cd7.jpg",
+        "text": "$$\nR _ { A } = \\gamma \\operatorname* { m a x } ( 0 , t _ { B } - t _ { A } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            747,
+            586,
+            765
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $t _ { A }$ is the time until Alice performs the STOP action, and $\\gamma$ is a scaling coefficient that balances this internal reward to be of the same scale as external rewards from the target task. The total length of an episode is limited to $t _ { \\mathrm { M a x } }$ , so if Bob fails to complete the task in time we set $t _ { B } = t _ { \\mathrm { M a x } } - t _ { A }$ . ",
+        "bbox": [
+            174,
+            776,
+            823,
+            820
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Thus Alice is rewarded if Bob takes more time, but the negative term on her own time will encourage Alice not to take too many steps when Bob is failing. For both reversible and resettable environments, Alice must limit her steps to make Bob’s task easier, thus Alice’s optimal behavior is to the find simplest tasks that Bob cannot complete. This eases learning for Bob since the new task will be only just beyond his current capabilities. The self-regulating feedback between Alice and Bob allows them to automatically construct a curriculum for exploration, a key contribution of our approach. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 PARAMETERIZING ALICE AND BOB’S ACTIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            540,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Alice and Bob each have policy functions which take as input two observations of state variables, and output a distribution over actions. In Alice’s case, the function will be of the form ",
+        "bbox": [
+            171,
+            131,
+            823,
+            160
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6206f692a500e6dc678b0696095753c9602c014a63e60dd2115557c28904a1aa.jpg",
+        "text": "$$\na _ { \\mathrm { A } } = \\pi _ { A } ( s _ { t } , s _ { 0 } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            169,
+            555,
+            186
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $s _ { 0 }$ is the observation of the initial state of the environment and $s _ { t }$ is the observation of the current state. In Bob’s case, the function will be ",
+        "bbox": [
+            173,
+            195,
+            825,
+            224
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9aba1e5411bc784fc3f549e54125284365f7d30fe050f0f4543b9367bf7586b6.jpg",
+        "text": "$$\na _ { \\mathrm { B } } = \\pi _ { B } ( s _ { t } , s ^ { * } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            234,
+            555,
+            252
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $s ^ { * }$ is the target state that Bob has to reach, and set to $s _ { 0 }$ when we have a reversible environment. In a resettable environment $s ^ { * }$ is the state where Alice executed the STOP action. ",
+        "bbox": [
+            174,
+            261,
+            825,
+            290
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "When a target task is presented, the agent’s policy function is $a _ { \\mathrm { T a r g e t } } = \\pi _ { B } ( s _ { t } , \\emptyset )$ , where the second argument of Bob’s policy is simply set to zero 1. If $s ^ { * }$ is always non-zero, then this is enough to let Bob know whether the current episode is self-play or target task. In some experiments where $s ^ { * }$ can be zero, we give third argument $z \\in \\{ 0 , 1 \\}$ that explicitly indicates the episode kind. ",
+        "bbox": [
+            174,
+            296,
+            825,
+            354
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the experiments below, we demonstrate our approach in settings where $\\pi _ { A }$ and $\\pi _ { B }$ are tabular; where it is a neural network taking discrete inputs, and where it is a neural network taking in continuous inputs. When using a neural network, we use the same network architecture for both Alice and Bob, except they have different parameters ",
+        "bbox": [
+            174,
+            361,
+            825,
+            417
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6bd4885786b4ec879bfd5102bce5b22e44dbeac720a64e6be9b91d558556af5f.jpg",
+        "text": "$$\n\\pi _ { A } ( s _ { t } , s _ { 0 } ) = f ( s _ { t } , s _ { 0 } , \\theta _ { A } ) , \\quad \\pi _ { B } ( s _ { t } , s ^ { \\ast } ) = f ( s _ { t } , s ^ { \\ast } , \\theta _ { B } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            428,
+            687,
+            445
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $f$ is an multi-layered neural network with parameters $\\theta _ { A }$ or $\\theta _ { B }$ . ",
+        "bbox": [
+            173,
+            454,
+            635,
+            469
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 UNIVERSAL BOB IN THE TABULAR SETTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            489,
+            519,
+            503
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now present a theoretical argument that shows for environments with finite states, tabular policies, and deterministic, Markovian transitions, we can interpret the self-play as training Bob to find a policy that can get from any state to any other in the least expected number of steps. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            559
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Preliminaries: Note that, as discussed above, the policy table for Bob is indexed by $( s _ { t } , s ^ { * } )$ , not just by $s _ { t }$ . In particular, with the assumptions above, this means that there is a fast policy $\\pi _ { \\mathrm { f a s t } }$ such that $\\pi _ { \\mathrm { f a s t } } ( s _ { t } , s ^ { * } )$ has the smallest expected number of steps to transition from $s _ { t }$ to $s ^ { * }$ . It is clear that $\\pi _ { \\mathrm { f a s t } }$ is a universal policy for Bob, such that $\\pi _ { B } = \\pi _ { \\mathrm { f a s t } }$ is optimal with respect to any Alice’s policy $\\pi _ { A }$ . In a reset game, $\\pi _ { \\mathrm { f a s t } }$ nets Alice a return of 0, and in the reverse game, the return of $\\pi _ { \\mathrm { f a s t } }$ against an optimal Alice can be considered a measure of the reversibility of the environment. However, in what follows let us assume that either the reset game or the reverse game in a perfectly reversible environment is used. Also, let assume the initial states are randomized and its distribution covers the entire state space. ",
+        "bbox": [
+            173,
+            565,
+            825,
+            690
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Claim: If $\\pi _ { A }$ and $\\pi _ { B }$ are policies of Alice and Bob that are in equilibrium (i.e., Alice cannot be made better without changing Bob, and vice-versa), then $\\pi _ { B }$ is a fast policy. ",
+        "bbox": [
+            174,
+            696,
+            821,
+            727
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Argument: Let us first show that Alice will always get zero reward in equilibrium. If Alice is getting positive reward on some challenge, that means Bob is taking longer than Alice on that challenge. Then Bob can be improved to use $\\pi _ { f a s t }$ at that challenge, which contradicts the equilibrium assumption. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            789
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Now let us prove $\\pi _ { B }$ is a fast policy by contradiction. If $\\pi _ { B }$ is not fast, then there must exist a challenge $( s _ { t } , s ^ { * } )$ where $\\pi _ { B }$ will take longer than $\\pi _ { f a s t }$ . Therefore Bob can get more reward by using $\\pi _ { f a s t }$ if Alice does propose that challenge with non-zero probability. Since we assumed equilibrium and $\\pi _ { B }$ cannot be improved while $\\pi _ { A }$ fixed, the only possibility is that Alice is never proposing that challenge. If that is true, Alice can get positive reward by proposing that task using the same actions as $\\pi _ { f a s t }$ , so taking fewer steps than $\\pi _ { B }$ . However this contradicts with the proof that Alice always gets zero reward, making our initial assumption $^ { 6 6 } \\pi _ { B }$ is not fast” wrong. ",
+        "bbox": [
+            174,
+            795,
+            825,
+            893
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            343,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Self-play arises naturally in reinforcement learning, and has been well studied. For example, for playing checkers (Samuel, 1959), backgammon (Tesauro, 1995), and Go, (Silver et al., 2016), and in multi-agent games such as RoboSoccer (Riedmiller et al., 2009). Here, the agents or teams of agents compete for external reward. This differs from our scheme where the reward is purely internal and the self-play is a way of motivating an agent to learn about its environment to augment sparse rewards from separate target tasks. ",
+        "bbox": [
+            174,
+            157,
+            825,
+            241
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our approach has some relationships with generative adversarial networks (GANs) (Goodfellow et al., 2014), which train a generative neural net by having it try to fool a discriminator network which tries to differentiate samples from the training examples. Li et al. (2017) introduce an adversarial approach to dialogue generation, where a generator model is subjected to a form of “Turing test” by a discriminator network. Mescheder et al. (2017) demonstrate how adversarial loss terms can be combined with variational auto-encoders to permit more accurate density modeling. While GAN’s are often thought of as methods for training a generator, the generator can be thought of as a method for generating hard negatives for the discriminator. From this viewpoint, in our approach, Alice acts as a “generator”, finding “negatives” for Bob. However, Bob’s jobs is to complete the generated challenge, not to discriminate it. ",
+        "bbox": [
+            174,
+            248,
+            825,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "There is a large body of work on intrinsic motivation (Barto, 2013; Singh et al., 2004; Klyubin et al., 2005; Schmidhuber, 1991) for self-supervised learning agents. These works propose methods for training an agent to explore and become proficient at manipulating its environment without necessarily having a specific target task, and without a source of extrinsic supervision. One line in this direction is curiosity-driven exploration (Schmidhuber, 1991). These techniques can be applied in encouraging exploration in the context of reinforcement learning, for example (Bellemare et al., 2016; Strehl & Littman, 2008; Lopes et al., 2012; Tang et al., 2016; Pathak et al., 2017); Roughly, these use some notion of the novelty of a state to give a reward. In the simplest setting, novelty can be just the number of times a state has been visited; in more complex scenarios, the agent can build a model of the world, and the novelty is the difficulty in placing the current state into the model. In our work, there is no explicit notion of novelty. Even if Bob has seen a state many times, if he has trouble getting to it, Alice should force him towards that state. Another line of work on intrinsic motivation is a formalization of the notion of empowerment (Klyubin et al., 2005), or how much control the agent has over its environment. Our work is related in the sense that it is in both Alice’s and Bob’s interests to have more control over the environment; but we do not explicitly measure that control except in relation to the tasks that Alice sets. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            617
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Curriculum learning (Bengio et al., 2009) is widely used in many machine learning approaches. Typically however, the curriculum requires at least some manual specification. A key point about our work is that Alice and Bob devise their own curriculum entirely automatically. Previous automatic approaches, such as Kumar et al. (2010), rely on monitoring training error. But since ours is unsupervised, no training labels are required either. ",
+        "bbox": [
+            174,
+            623,
+            823,
+            694
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our basic paradigm of “Alice proposing a task, and Bob doing it” is related to the Horde architecture (Sutton et al., 2011) and (Schaul et al., 2015). In those works, instead of using a value function $V = V ( s )$ that depends on the current state, a value function that explicitly depends on state and goal $V = V ( s , g )$ is used. In our experiments, our models will be parameterized in a similar fashion. The novelty in this work is in how Alice defines the goal for Bob. ",
+        "bbox": [
+            174,
+            700,
+            823,
+            770
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The closest work to ours is that of Baranes & Oudeyer (2013), who also have one part of the model that proposes tasks, while another part learns to complete them. As in this work, the policies and cost are parameterized as functions of both state and goal. However, our approach differs in the way tasks are proposed and communicated. In particular, in Baranes & Oudeyer (2013), the goal space has to be presented in a way that allows explicit partitioning and sampling, whereas in our work, the goals are sampled through Alice’s actions. On the other hand, we pay for not having to have such a representation by requiring the environment to be either reversible or resettable. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Several concurrent works are related: Andrychowicz et al. (2017) form an implicit curriculum by using internal states as a target. Florensa et al. (2017) automatically generate a series of increasingly distant start states from a goal. Pinto et al. (2017) use an adversarial framework to perturb the environment, inducing improved robustness of the agent. Held et al. (2017) propose a scheme related to our “random Alice” strategy2. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            146,
+            328,
+            161
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The following experiments explore our self-play approach on a variety of tasks, both continuous and discrete, from the Mazebase (Sukhbaatar et al., 2015), RLLab (Duan et al., 2016), and StarCraft (Synnaeve et al., 2016) environments. The same protocol is used in all settings: self-play and target task episodes are mixed together and used to train the agent via discrete policy gradient. We evaluate both the reverse and repeat versions of self-play. We demonstrate that the self-play episodes help training, in terms of number of target task episodes needed to learn the task. Note that we assume the self-play episodes to be “free”, since they make no use of environmental reward. This is consistent with traditional semi-supervised learning, where evaluations typically are based only on the number of labeled points (not unlabeled ones too). ",
+        "bbox": [
+            173,
+            169,
+            825,
+            295
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In all the experiments we use policy gradient (Williams, 1992) with a baseline for optimizing the policies. In the tabular task below, we use a constant baseline; in all the other tasks we use a policy parameterized by a neural network, and a baseline that depends on the state. We denote the states in an episode by $s _ { 1 } , . . . , s _ { T }$ , and the actions taken at each of those states as $a _ { 1 } , . . . , a _ { T }$ , where $T$ is the length of the episode. The baseline is a scalar function of the states $b ( s , \\theta )$ , computed via an extra head on the network producing the action probabilities. Besides maximizing the expected reward with policy gradient, the models are also trained to minimize the distance between the baseline value and actual reward. Thus after finishing an episode, we update the model parameters $\\theta$ by ",
+        "bbox": [
+            173,
+            300,
+            825,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dc6c9ad6cdeeb4d42a115f900e96f4619d7b1a30299f3fb6795ec735a5a54e25.jpg",
+        "text": "$$\n\\Delta \\theta = \\sum _ { t = 1 } ^ { T } \\left[ \\frac { \\partial \\log f ( a _ { t } | s _ { t } , \\theta ) } { \\partial \\theta } \\left( \\sum _ { i = t } ^ { T } r _ { i } - b ( s _ { t } , \\theta ) \\right) - \\lambda \\frac { \\partial } { \\partial \\theta } \\left( \\sum _ { i = t } ^ { T } r _ { i } - b ( s _ { t } , \\theta ) \\right) ^ { 2 } \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            228,
+            420,
+            767,
+            467
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here $r _ { t }$ is reward given at time $t$ , and the hyperparameter $\\lambda$ is for balancing the reward and the baseline objectives, which is set to 0.1 in all experiments. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For the policy neural networks, we use two-layer fully-connected networks with 50 hidden units in each layer. The training uses RMSProp (Tieleman & Hinton, 2012). We always do 10 runs with different random initializations and report their mean and standard deviation. See Appendix $\\mathbf { B }$ for all the hyperparameter values used in the experiments. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 LONG HALLWAY",
+        "text_level": 1,
+        "bbox": [
+            174,
+            575,
+            326,
+            589
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first describe a simple toy environment designed to illustrate the function of the asymmetric selfplay. The environment consists of $M$ states $\\{ \\bar { s _ { 1 } } , . . . , s _ { M } \\}$ arranged in a chain. Both Alice and Bob have three possible actions, “left”, “right”, or “stop”. If the agent is at $s _ { i }$ with $i \\neq 1$ , “left” takes it to $s _ { i - 1 }$ ; “right” analogously increases the state index, and “stop” transfers control to Bob when Alice runs it and terminates the episode when Bob runs it. We use “return to initial state” as the self-play task (i.e. Reverse in Algorithm 1 in Appendix A ). For the target task, we randomly pick a starting state and target state, and the episode is considered successful if Bob moves to the target state and executes the stop action before a fixed number of maximum steps. ",
+        "bbox": [
+            173,
+            601,
+            825,
+            712
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this case, the target task is essentially the same as the self-play task, and so running it is not unsupervised learning (and in particular, on this toy example unlike the other examples below, we do not mix self-play training with target task training). However, we see that the curriculum afforded by the self-play is efficient at training the agent to do the target task at the beginning of the training, and is effective at forcing exploration of the state space as Bob gets more competent. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            790
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 2 (left) we plot the number of episodes vs rate of success at the target task with four different methods. We set $M = 2 5$ and the maximum allowed steps for Alice and Bob to be 30. We use fully tabular controllers; the table is of size $M ^ { 2 } \\times 3$ , with a distribution over the three actions for each possible (start, end pair). ",
+        "bbox": [
+            173,
+            795,
+            825,
+            852
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The red curve corresponds to policy gradient, with a penalty of $- 1$ given upon failure to complete the task, and a penalty of $- t / t _ { \\mathrm { M a x } }$ for successfully completing the task in $t$ steps. The magenta curve corresponds to taking Alice to have a random policy $( 1 / 2$ probability of moving left or right, and not stopping till the maximum allowed steps). The green curve corresponds to policy gradient with an exploration bonus similar to Strehl & Littman (2008). That is, we keep count of the number of times√ $N _ { s }$ the agent has been in each state $s$ , and the reward for $s$ is adjusted by exploration bonus $\\alpha / \\sqrt { N _ { s } }$ , where $\\alpha$ is a constant balancing the reward from completing the task with the exploration bonus. We choose the weight $\\alpha$ to maximize success at $\\phantom { - } 0 . 2 \\mathbf { M }$ episodes from the set $\\{ 0 , 0 . 1 , 0 . 2 , . . . , 1 \\}$ . The blue curve corresponds to the asymmetric self-play training. ",
+        "bbox": [
+            176,
+            858,
+            821,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We can see that at the very beginning, a random policy for Alice gives some form of curriculum but eventually is harmful, because Bob never gets to see any long treks. On the other hand, policy gradient sees very few successes in the beginning, and so trains slowly. Using the self-play method, Alice gives Bob easy problems at first (she starts from random), and then builds harder and harder problems as the training progresses, finally matching the performance boost of the count based exploration. Although not shown, similar patterns are observed for a wide range of learning rates. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            291
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 MAZEBASE: LIGHT KEY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            306,
+            382,
+            320
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We now describe experiments using the MazeBase environment (Sukhbaatar et al., 2015), which have discrete actions and states, but sufficient combinatorial complexity that tabular methods cannot be used. The environment consist of various items placed on a finite 2D grid; and randomly generated for each episode. ",
+        "bbox": [
+            174,
+            334,
+            823,
+            390
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use an environment where the maze contains a light switch (whose initial state is sampled according to a predefined probability, p(Light off)), a key and a wall with a door (see Fig. 1). An agent can open or close the door by toggling the key switch, and turn on or off light with the light switch. When the light is off, the agent can only see the (glowing) light switch. In the target task, there is also a goal flag item, and the objective of the game is reach to that goal flag. ",
+        "bbox": [
+            174,
+            397,
+            823,
+            467
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In self-play, the environment is the same except there is no specific objective. An episode starts with Alice in control, who can navigate through the maze and change the switch states until she outputs the STOP action. Then, Bob takes control and tries to return everything to its original state (restricted to visible items) in the reverse self-play. In the repeat version, the maze resets back to its initial state when Bob takes the control, who tries to reach the final state of Alice. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            542
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 2 (right), we set p(Light off) $= 0 . 5$ during self-play3 and evaluate the repeat form of self-play, alongside two baselines: (i) target task only training (i.e. no self-play) and (ii) self-play with a random policy for Alice. With self-play, the agent succeeds quickly while target task-only training takes much longer4. Fig. 3 shows details of a single training run, demonstrating how Alice and Bob automatically build a curriculum between themselves though self-play. ",
+        "bbox": [
+            174,
+            550,
+            825,
+            621
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 RLLAB: MOUNTAIN CAR ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            641,
+            392,
+            656
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We applied our approach to the Mountain Car task in RLLab. Here the agent controls a car trapped in a 1-D valley. It must learn to build momentum by alternately moving to the left and right, climbing higher up the valley walls until it is able to escape. Although the problem is presented as continuous, we discretize the 1-D action space into 5 bins (uniformly sized) enabling us to use discrete policy gradient, as above. We also added a secondary action head with binary actions to be used as STOP action. An observation of state $s _ { t }$ consists of the location and speed of the car. ",
+        "bbox": [
+            174,
+            669,
+            825,
+            752
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As in Houthooft et al. (2016); Tang et al. (2016), a reward of $+ 1$ is given only when the car succeeds in climbing the hill. In self-play, Bob succeeds if $\\| s _ { b } - s _ { a } \\| < 0 . 2$ , where $s _ { a }$ and $s _ { b }$ are the final states (location and velocity of the car) of Alice and Bob respectively. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            803
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The nature of the environment makes it highly asymmetric from Alice and Bob’s point of view, since it is far easier to coast down the hill to the starting point that it is to climb up it. Hence we exclusively use the reset form of self-play. In Fig. 4 (left), we compare this to current state-of-the-art methods, namely VIME (Houthooft et al., 2016) and SimHash (Tang et al., 2016). Our approach (blue) performs comparably to both of these. We also tried using policy gradient directly on the target task samples, but it was unable to solve the problem. ",
+        "bbox": [
+            174,
+            809,
+            825,
+            866
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/fd97037d7dfd8b0c298fff0cc2c18d95ac0f656b56a8068fb1ee8e614ef71d71.jpg",
+        "image_caption": [
+            "Figure 2: Left: The hallway task from section 4.1. The $y$ axis is fraction of successes on the target task, and the $x$ axis is the total number of training examples seen. Standard policy gradient (red) learns slowly. Adding an explicit exploration bonus (Strehl & Littman, 2008) (green) helps significantly. Our self-play approach (blue) gives similar performance however. Using a random policy for Alice (magenta) drastically impairs performance, showing the importance of self-play between Alice and Bob. Right: Mazebase task, illustrated in Fig. 1, for p(Light off) $= 0 . 5$ . Augmenting with the repeat form of self-play enables significantly faster learning than training on the target task alone and random Alice baselines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            102,
+            776,
+            270
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f5ed4f61d0e7add8c1f00c093478873a71cfc2e186ade55e93fc03d269aa09ed.jpg",
+        "image_caption": [
+            "Figure 3: Inspection of a Mazebase learning run, using the environment shown in Fig. 1. (a): rate at which Alice interacts with 1, 2 or 3 objects during an episode, illustrating the automatically generated curriculum. Initially Alice touches no objects, but then starts to interact with one. But this rate drops as Alice devises tasks that involve two and subsequently three objects. (b) by contrast, in the random Alice baseline, she never utilizes more than a single object and even then at a much lower rate. (c) plot of Alice and Bob’s reward, which strongly correlates with (a). (d) plot of $t _ { a }$ as self-play progresses. Alice takes an increasing amount of time before handing over to Bob, consistent with tasks of increasing difficulty being set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            424,
+            825,
+            534
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            678,
+            821,
+            707
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 RLLAB: SWIMMERGATHER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            733,
+            406,
+            747
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also applied our approach to the SwimmerGather task in RLLab (which uses the Mujoco (Todorov et al., 2012) simulator), where the agent controls a worm with two flexible joints, swimming in a 2D viscous fluid. In the target task, the agent gets reward $+ 1$ for eating green apples and -1 for touching red bombs, which are not present during self-play. Thus the self-play task and target tasks are different: in the former, the worm just swims around but in the latter it must learn to swim towards green apples and away from the red bombs. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The observation state consists of a 13-dimensional vector describing location and joint angles of the worm, and a 20 dimensional vector for sensing nearby objects. The worm takes two real values as an action, each controlling one joint. We add a secondary action head to our models to handle the 2nd joint, and a third binary action head for STOP action. As in the mountain car, we discretize the output space (each joint is given 9 uniformly sized bins) to allow the use of discrete policy gradients. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Bob succeeds in a self-play episode when $\\| l _ { b } - l _ { a } \\| < 0 . 3$ where $l _ { a }$ and $l _ { b }$ are the final locations of Alice and Bob respectively. Fig. 4 (right) shows the target task reward as a function of training iteration for our approach alongside state-of-the-art exploration methods VIME (Houthooft et al., 2016) and SimHash (Tang et al., 2016). We demonstrate the generality of the self-play approach by applying it to Reinforce and also TRPO (Schulman et al., 2015) (see Appendix D for details). In both cases, it enables them to gain reward significantly earlier than other methods, although both converge to a similar final value to SimHash. A video of our worm performing the test task can be found at https://goo.gl/Vsd8Js. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/7bc22b89f7cabb0fb8047c902b16342f1019591342f2ef3dd6922a1ef4dc3629.jpg",
+        "image_caption": [
+            "Figure 4: Evaluation on MountainCar (left) and SwimmerGather (right) target tasks, comparing to VIME Houthooft et al. (2016) and SimHash Tang et al. (2016) (figures adapted from Tang et al. (2016)). With reversible self-play we are able to learn faster than the other approaches, although it converges to a comparable reward. Training directly on the target task using Reinforce without self-play resulted in total failure. Here 1 iteration $= 5 \\mathrm { k }$ (50k) target task steps in Mountain car (SwimmerGather), excluding self-play steps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            228,
+            808,
+            377
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.5 STARCRAFT: TRAINING MARINES ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            468,
+            449,
+            483
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, we applied our self-play approach to the same setup as the beginning of a standard StarCraft: Brood War game Synnaeve et al. (2016), where an agent controls multiple units to mine, construct buildings, and train new units, but without enemies to fight. The environment starts with 4 workers units (Terran SCVs), who can move around, mine nearby minerals and construct new buildings. In addition, the agent controls the command center, which can train new workers. See Fig. 5 (left) for relations between different units and their actions. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            577
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The target task is to build Marine units. To do this, an agent must follow a specific sequence of operations: (i) mine minerals with workers; (ii) having accumulated sufficient mineral supply, build a barracks and (iii) once the barracks are complete, train Marine units out of it. Optionally, an agent can train a new worker for faster mining, or build a supply depot to accommodate more units. When the episode ends after 200 steps (little over 3 minutes), the agent gets rewarded $+ 1$ for each Marine it has built. Optimizing this task is highly complex due to several factors. First, the agent has to find an optimal mining pattern (concentrating on a single mineral or mining a far away mineral is inefficient). Then, it has to produce the optimal number of workers and barrack at the right timing. In addition, a supply depot needs to be built when the number of units is close to the limit. ",
+        "bbox": [
+            174,
+            584,
+            825,
+            710
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "During self-play (repeat variant), Alice and Bob control the workers and can try any combination of actions during the episode. Since exactly matching the game state is almost impossible, Bob’s success is only based on the global state of the game, which includes the number of units of each type (including buildings), and accumulated mineral resource. So Bob’s objective in self-play is to make as many units and mineral as Alice in shortest possible time. Further details are given in Appendix E. Fig. 5 (right) compares the Reinforce algorithm on the target task, with and without self-play. An additional count-based exploration baseline similar to the hallway experiment is also shown. It utilizes the same global game state as self-play. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            829
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            849,
+            310,
+            866
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work we described a novel method for intrinsically motivated learning which we call asymmetric self-play. Despite the method’s conceptual simplicity, we have seen that it can be effective in both discrete and continuous input settings with function approximation, for encouraging exploration and automatically generating curriculums. On the challenging benchmarks we consider, our approach is at least as good as state-of-the-art RL methods that incorporate an incentive for exploration, despite being based on very different principles. Furthermore, it is possible show theoretically that in simple environments, using asymmetric self-play with reward functions from (1) and (2), optimal agents can transit between any pair of reachable states as efficiently as possible. Code for our approach can be found at (link removed for anonymity). ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/9d740b096917a0ed320f9d5dee4a1dea5a4333c2557c3fc29fe88147178a37a1.jpg",
+        "image_caption": [
+            "Figure 5: Left: Different types of unit in the StarCraft environment. The arrows represent possible actions (excluding movement actions) by the unit, and corresponding numbers shows (blue) amount of minerals and (red) time steps needed to complete. The units under agent’s control are outlined by a green border. Right: Plot of reward on the StarCraft sub-task of training marine units vs #target-task episodes (self-play episodes are not included), with and without self-play. A count-based baseline is also shown. Self-play greatly speeds up learning, and also surpasses the count-based approach at convergence. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            103,
+            784,
+            243
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            386,
+            825,
+            469
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            492,
+            285,
+            507
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. CoRR, abs/1707.01495, 2017. URL http://arxiv.org/abs/1707.01495. ",
+        "bbox": [
+            176,
+            515,
+            821,
+            558
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A. Baranes and P-Y. Oudeyer. Active learning of inverse models with intrinsically motivated goal exploration in robots. Robotics and Autonomous Systems, 61(1):49–73, 2013. ",
+        "bbox": [
+            166,
+            568,
+            823,
+            597
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrew G. Barto. Intrinsic Motivation and Reinforcement Learning, pp. 17–47. Springer Berlin Heidelberg, 2013. ",
+        "bbox": [
+            173,
+            606,
+            821,
+            636
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marc G. Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi´ Munos. Unifying count-based exploration and intrinsic motivation. In NIPS, pp. 1471–1479, 2016. ",
+        "bbox": [
+            173,
+            645,
+            823,
+            688
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Jer´ ome Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In ˆ ICML, pp. 41–48, 2009. ",
+        "bbox": [
+            174,
+            698,
+            823,
+            727
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continuous control. In ICML, 2016. ",
+        "bbox": [
+            174,
+            737,
+            823,
+            765
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Carlos Florensa, David Held, Markus Wulfmeier, and Pieter Abbeel. Reverse curriculum generation for reinforcement learning. CoRR, abs/1707.05300, 2017. URL http://arxiv.org/abs/ 1707.05300. ",
+        "bbox": [
+            173,
+            775,
+            823,
+            818
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, pp. 2672–2680, 2014. ",
+        "bbox": [
+            173,
+            828,
+            823,
+            871
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Held, Xinyang Geng, Carlos Florensa, and Pieter Abbeel. Automatic goal generation for reinforcement learning agents. CoRR, abs/1705.06366, 2017. URL http://arxiv.org/ abs/1705.06366. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rein Houthooft, Xi Chen, Yan Duan, John Schulman, Filip De Turck, and Pieter Abbeel. Curiosity-driven exploration in deep reinforcement learning via bayesian neural networks. arXiv 1605.09674, 2016. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexander S. Klyubin, Daniel Polani, and Chrystopher L. Nehaniv. Empowerment: a universal agent-centric measure of control. In Proceedings of the IEEE Congress on Evolutionary Computation, CEC, pp. 128–135, 2005. ",
+        "bbox": [
+            174,
+            155,
+            821,
+            198
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "M. P. Kumar, Benjamin Packer, and Daphne Koller. Self-paced learning for latent variable models. In NIPS. 2010. ",
+        "bbox": [
+            173,
+            205,
+            820,
+            236
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jiwei Li, Will Monroe, Tianlin Shi, Alan Ritter, and Dan Jurafsky. Adversarial learning for neural dialogue generation. arXiv 1701.06547, 2017. ",
+        "bbox": [
+            173,
+            244,
+            821,
+            273
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Manuel Lopes, Tobias Lang, Marc Toussaint, and Pierre-Yves Oudeyer. Exploration in model-based reinforcement learning by empirically estimating learning progress. In NIPS, pp. 206–214, 2012. ",
+        "bbox": [
+            171,
+            281,
+            821,
+            311
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lars M. Mescheder, Sebastian Nowozin, and Andreas Geiger. Adversarial variational bayes: Unifying variational autoencoders and generative adversarial networks. arXiv abs/1701.04722, 2017. ",
+        "bbox": [
+            173,
+            319,
+            821,
+            349
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak, Pulkit Agrawal, Alexei A. Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. In ICML, 2017. ",
+        "bbox": [
+            174,
+            357,
+            821,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lerrel Pinto, James Davidson, Rahul Sukthankar, and Abhinav Gupta. Robust adversarial reinforcement learning. CoRR, abs/1703.02702, 2017. URL http://arxiv.org/abs/1703. 02702. ",
+        "bbox": [
+            174,
+            396,
+            821,
+            439
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin Riedmiller, Thomas Gabel, Roland Hafner, and Sascha Lange. Reinforcement learning for robot soccer. Autonomous Robots, 27(1):55–73, 2009. ",
+        "bbox": [
+            173,
+            446,
+            823,
+            477
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arthur L. Samuel. Some studies in machine learning using the game of checkers. IBM Journal of Research and Development, 3(3):210–229, 1959. ",
+        "bbox": [
+            174,
+            486,
+            825,
+            515
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, Dan Horgan, Karol Gregor, and David Silver. Universal value function approximators. In ICML, pp. 1312–1320, 2015. ",
+        "bbox": [
+            174,
+            522,
+            823,
+            553
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "J. Schmidhuber. Curious model-building control systems. In Proc. Int. J. Conf. Neural Networks, pp. 1458–1463. IEEE Press, 1991. ",
+        "bbox": [
+            173,
+            560,
+            823,
+            590
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Philipp Moritz, Michael I. Jordan, and Pieter Abbeel. Trust region policy optimization. arXiv1502.05477, 2015. ",
+        "bbox": [
+            173,
+            598,
+            823,
+            628
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, Sander Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy Lillicrap, Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of Go with deep neural networks and tree search. Nature, 529(7587):484–489, January 2016. ",
+        "bbox": [
+            173,
+            636,
+            826,
+            707
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Satinder P. Singh, Andrew G. Barto, and Nuttapong Chentanez. Intrinsically motivated reinforcement learning. In NIPS, pp. 1281–1288, 2004. ",
+        "bbox": [
+            169,
+            715,
+            823,
+            746
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexander L. Strehl and Michael L. Littman. An analysis of model-based interval estimation for markov decision processes. J. Comput. Syst. Sci., 74(8):1309–1331, 2008. ",
+        "bbox": [
+            169,
+            753,
+            823,
+            784
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Arthur Szlam, Gabriel Synnaeve, Soumith Chintala, and Rob Fergus. Mazebase: A sandbox for learning from games. arXiv 1511.07401, 2015. ",
+        "bbox": [
+            169,
+            791,
+            823,
+            821
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard S. Sutton, Joseph Modayil, Michael Delp, Thomas Degris, Patrick M. Pilarski, Adam White, and Doina Precup. Horde: A scalable real-time architecture for learning knowledge from unsupervised sensorimotor interaction. In AAMAS ’11, pp. 761–768, 2011. ",
+        "bbox": [
+            176,
+            829,
+            823,
+            873
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Synnaeve, Nantas Nardelli, Alex Auvolat, Soumith Chintala, Timothee Lacroix, Zeming ´ Lin, Florian Richoux, and Nicolas Usunier. Torchcraft: a library for machine learning research on real-time strategy games. arXiv preprint arXiv:1611.00625, 2016. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "H. Tang, R. Houthooft, D. Foote, A. Stooke, X. Chen, Y. Duan, J. Schulman, F. De Turck, and P. Abbeel. #exploration: A study of count-based exploration for deep reinforcement learning. arXiv abs/1611.04717, 2016. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gerald Tesauro. Temporal difference learning and td-gammon. Commun. ACM, 38(3):58–68, 1995. ",
+        "bbox": [
+            173,
+            154,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "T. Tieleman and G. Hinton. Lecture 6.5 - rmsprop, coursera: Neural networks for machine learning, 2012. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            207
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In IROS, pp. 5026–5033. IEEE, 2012. ",
+        "bbox": [
+            174,
+            214,
+            821,
+            244
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. In Machine Learning, pp. 229–256, 1992. ",
+        "bbox": [
+            173,
+            252,
+            823,
+            281
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A PSEUDO CODE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            306,
+            333,
+            324
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 and 2 are the pseudo codes for training an agent on self-play and target task episodes. ",
+        "bbox": [
+            173,
+            338,
+            815,
+            353
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Pseudo code for training an agent on a self-play episode ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            368,
+            630,
+            382
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/10da804eb7b8aba25b54aa9cc6f1d6d4fcd5cc0be34d28f04fb28640c08cbe71.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>function SELFPLAYEPISODE(REVERSE/REPEAT,tMAx,0A,0B)</td></tr><tr><td>tA↑0 So←env.observe()</td></tr><tr><td>S* ↑</td></tr><tr><td>while True do</td></tr><tr><td># Alice&#x27;s turn</td></tr><tr><td>tA←tA+1</td></tr><tr><td>s ← env.observe()</td></tr><tr><td>a←πA(s,so)=f(s,So,0A)</td></tr><tr><td>if α = STOP or tA ≥ tMax then</td></tr><tr><td>s*↑s env.reset()</td></tr><tr><td>break</td></tr><tr><td>env.act(a)</td></tr><tr><td>tb↑0</td></tr><tr><td>while True do</td></tr><tr><td>#Bob&#x27;s turn</td></tr><tr><td>s← env.observe()</td></tr><tr><td>if s= s*or tA+tb≥tMax then</td></tr><tr><td>break</td></tr><tr><td>tb←tb+1</td></tr><tr><td>a←TB(s,s*)=f(s,s*,0B)</td></tr><tr><td>env.act(a)</td></tr><tr><td>RA←γmax(O,tB-tA)</td></tr><tr><td>RB←-γtB</td></tr><tr><td></td></tr><tr><td>policy.update(RA, 0A)</td></tr><tr><td>policy.update(RB,0B)</td></tr><tr><td>return</td></tr></table>",
+        "bbox": [
+            171,
+            382,
+            823,
+            746
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B HYPERPARAMETERS USED IN THE EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            773,
+            614,
+            789
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For the experiments with neural networks, all parameters are randomly initialized from $\\mathcal { N } ( 0 , 0 . 2 )$ . The Hyperparameters of RMSProp are set to 0.97 and $1 e - 6$ . The other hyperparameter values used in the experiments are shown in Table 1. In some cases, we used different parameters for self-play and target task episodes. Entropy regularization is implemented as an additional cost maximizing the entropy of the softmax layer. In the StarCraft, skipping 23 frames roughly matches to one action per second. ",
+        "bbox": [
+            173,
+            804,
+            825,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Pseudo code for training an agent on a target task episode ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            640,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "function TARGETTASKEPISODE(tMAX, θB) t ← 0 R ← 0 while True do $t \\gets t + 1$ $s $ env.observe() $a  \\pi _ { B } ( s , \\emptyset ) = f ( s , \\emptyset , \\theta _ { B } )$ if env.done() or $t \\geq t _ { \\mathrm { M a x } }$ then break env.act(a) $R = R +$ env.reward() policy.update $( R , \\theta _ { B } )$ return ",
+        "bbox": [
+            173,
+            111,
+            452,
+            289
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/18b7d67809c881afc72e3e33a341668ed1c5470680a303c2afa6363f1671be21.jpg",
+        "table_caption": [
+            "Table 1: Hyperparameter values used in experiments. $\\mathrm { T T } { = }$ target task, $\\mathrm { S P = }$ self-play "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Hyperparametername</td><td rowspan=1 colspan=1>LongHallway</td><td rowspan=1 colspan=1>Mazebase</td><td rowspan=1 colspan=1>MountainCar</td><td rowspan=1 colspan=1>SwimmerGather</td><td rowspan=1 colspan=1>StarCraft</td></tr><tr><td rowspan=1 colspan=1>Learning rate</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.003</td><td rowspan=1 colspan=1>0.003</td><td rowspan=1 colspan=1>0.003</td><td rowspan=1 colspan=1>0.003</td></tr><tr><td rowspan=1 colspan=1>Batch size</td><td rowspan=1 colspan=1>16</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>128</td><td rowspan=1 colspan=1>256</td><td rowspan=1 colspan=1>32</td></tr><tr><td rowspan=1 colspan=1>Max steps ofepisode (tmax)</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>500</td><td rowspan=1 colspan=1>TT: 166SP: 200</td><td rowspan=1 colspan=1>200</td></tr><tr><td rowspan=1 colspan=1>Entropyregularization</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.003</td><td rowspan=1 colspan=1>0.003</td><td rowspan=1 colspan=1>TT: 0SP: 0.003</td><td rowspan=1 colspan=1>TT: 0SP: 0.003</td></tr><tr><td rowspan=1 colspan=1>Self-play reward scale (γ)</td><td rowspan=1 colspan=1>0.033</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.01</td></tr><tr><td rowspan=1 colspan=1>Self-play percentage</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>20%</td><td rowspan=1 colspan=1>1%</td><td rowspan=1 colspan=1>10%</td><td rowspan=1 colspan=1>10%</td></tr><tr><td rowspan=1 colspan=1>Self-play mode</td><td rowspan=1 colspan=1>Reverse</td><td rowspan=1 colspan=1>Both</td><td rowspan=1 colspan=1>Repeat</td><td rowspan=1 colspan=1>Reverse</td><td rowspan=1 colspan=1>Repeat</td></tr><tr><td rowspan=1 colspan=1>Frame skip</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>1505</td><td rowspan=1 colspan=1>23</td></tr></table>",
+        "bbox": [
+            196,
+            304,
+            800,
+            479
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C MAZEBASE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            531,
+            305,
+            547
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The agent has full visibility of the maze when the light is on. If light is off, the agent can only see the light switch. In self-play, Bob does not need to worry about things that are invisible to him. For example, if Alice started with light “off” in reverse self-play, Bob does not need to match the state of the door, because it would be invisible to him when the light is off. ",
+        "bbox": [
+            174,
+            563,
+            823,
+            618
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In the target task, the agent and the goal are always placed on opposite sides of the wall. Also, the light and key switches are placed on the same side as the agent, but the light is always off and the door is closed initially. Therefore, in order to succeed, the agent has to turn on the light, toggle the key switch to open the door, pass through it, and reach the goal flag. ",
+        "bbox": [
+            174,
+            626,
+            825,
+            683
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Both Alice and Bob’s policies are modeled by a fully-connected neural network with two hidden layers each with 100 and 50 units (with tanh non-linearities) respectively. The encoder into each of the networks takes a bag of words over (objects, locations); that is, there is a separate word in the lookup table for each (object, location) pair. Action probabilities are output by a linear layer followed by a softmax. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            758
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C.1 BIASING FOR OR AGAINST SELF-PLAY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            776,
+            478,
+            790
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The effectiveness of our approach depends in part on the similarity between the self-play and target tasks. One way to explore this in our environment is to vary the probability of the light being off initially during self-play episodes6. Note that the light is always off in the target task; if the light is usually on at the start of Alice’s turn in reverse, for example, she will learn to turn it off, and then Bob will be biased to turn it back on. On the other hand, if the light is usually off at the start of Alice’s turn in reverse, Bob is strongly biased against turning the light on, and so the test task becomes especially hard. Thus changing this probability gives us some way to adjust the similarity between the two tasks. ",
+        "bbox": [
+            174,
+            803,
+            825,
+            887
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Fig. 6 (left) shows what happens when p(Light off) $\\scriptstyle 1 = 0 . 3$ . Here reverse self-play works well, but repeat self-play does poorly. As discussed above, this flipping, relative to the previous experiment, can be explained as follows: low p(Light off) means that Bob’s task in reverse self-play will typically involve returning the light to the on position (irrespective of how Alice left it), the same function that must be performed in the target task. The opposite situation applies for repeat self-play, where Bob needs to encounter the light typically in the off position to help him with the test task. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            223
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 6 (right) we systematically vary p(Light off) between 0.1 and 0.9. The y-axis shows the speed-up (reduction in target task episodes) relative to training purely on the target-task for runs where the reward goes above -2. Unsuccessful runs are given a unity speed-up factor. The curves show that when the self-play task is not biased against the target task it can help significantly. ",
+        "bbox": [
+            174,
+            229,
+            825,
+            285
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/9dea24e2b8a3722d9cd26042796350f4c072933e9ae2a56930497eb412a13080.jpg",
+        "image_caption": [
+            "Figure 6: Left: The performance of self-play when p(Light off) set to 0.3. Here the reverse form of self-play works well (more details in the text). Right: Reduction in target task episodes relative to training purely on the target-task as the distance between self-play and the target task varies (for runs where the reward goes above -2 on the Mazebase task – unsuccessful runs are given a unity speed-up factor). The $y$ axis is the speedup, and $x$ axis is p(Light off). For reverse self-play, the low p(Light off) corresponds to having self-play and target tasks be similar to one another, while the opposite applies to repeat self-play. For both forms, significant speedups are achieved when self-play is similar to the target tasks, but the effect diminishes when self-play is biased against the target task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            299,
+            774,
+            467
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D SWIMMERGATHER EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            636,
+            482,
+            652
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 7 shows details of a single training run. The changes in Alice’s behavior, observed in Fig. 7(c) and (d), correlate with Alice and Bob’s reward (Fig. 7(b)) and, initially at least, to the reward on the test target (Fig. 7(a)). In Fig. 8 we visualize for a single training run the locations where Alice hands over to Bob at different stages of training, showing how the distribution varies. ",
+        "bbox": [
+            173,
+            667,
+            825,
+            723
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/b10cab091594486bf3cd8e30bf5f5e097c7495e15a6c3fc55af13e6bba396f50.jpg",
+        "image_caption": [
+            "Figure 7: A single SwimmerGather training run. (a): Rewards on target task. (b): Rewards from reversible self-play. (c): The number of actions taken by Alice. (d): Distance that Alice travels before switching to Bob. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            736,
+            821,
+            834
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In the TRPO experiment, we used step size 0.01 and damping coefficient 0.1. The batch consists of 50,000 steps, of which $2 5 \\%$ comes from target task episodes, while the remaining $7 5 \\%$ is from self-play. The self-play reward scale $\\gamma$ set to 0.005. We used two separate network for actor and critic, and the critic network has L2 weight regularization with coefficient of $1 e - 5$ . ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/b209fac1472f9619db92043d1ca7cfb06e742f027316975d973929360291b5f7.jpg",
+        "image_caption": [
+            "Figure 8: Plot of Alice’s location at time of STOP action for the SwimmerGather training run shown in Fig. 7, for different stages of training. Note how Alice’s distribution changes as Bob learns to solve her tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            101,
+            743,
+            195
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            284,
+            821,
+            313
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E STARCRAFT EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            337,
+            426,
+            353
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We call units that perform action as active unit. This includes worker units (SCVs), the command center, and barrack. The agent controls multiple active units in parallel. At each time step, an action of $\\because$ ’th unit is output by ",
+        "bbox": [
+            173,
+            369,
+            825,
+            412
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/156ee02f0e9d056f52f523961ab42ed450f94b80c470f6e89110890b2f7e5694.jpg",
+        "text": "$$\na _ { t } ^ { i } = \\pi ( s _ { t } ^ { i } , { \\hat { s } } _ { t } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            449,
+            415,
+            547,
+            434
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "where $s _ { t } ^ { i }$ is a unit specific local observation, and $\\hat { s } _ { t }$ is an global observation. With $s _ { t } ^ { i }$ , a unit can see the $6 4 \\mathrm { x } 6 4$ area around it with a resolution of 4 (unit’s type is also visible). The global observation contains the number of units and accumulated minerals in the game ",
+        "bbox": [
+            174,
+            441,
+            825,
+            484
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ff6abc688e06380951317d58f005e61f97237ee5436c2bd9634ef83d50dcc387.jpg",
+        "text": "$$\n\\hat { s } _ { t } = \\{ \\lfloor N _ { \\mathrm { o r e } } / 2 5 \\rfloor , N _ { \\mathrm { S C V } } , N _ { \\mathrm { B a r r a c k } } , N _ { \\mathrm { S u p p l y D e p o t } } , N _ { \\mathrm { M a r i n e s } } \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            493,
+            681,
+            512
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In self-play, Bob perceives only the global observation of his target state ",
+        "bbox": [
+            173,
+            529,
+            647,
+            545
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/427eaee0cb08feb51d5139d676fe9fc3a30b7814f19234f39e435dea75c4a225.jpg",
+        "text": "$$\n\\pi _ { B } \\big ( s _ { t } ^ { i } , \\hat { s } _ { t } , \\hat { s } ^ { * } \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            449,
+            553,
+            545,
+            571
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { s } ^ { * }$ is the final global observation of Alice. Bob will succeed only if ",
+        "bbox": [
+            173,
+            582,
+            658,
+            597
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b6e169b370ad675a3175726e8c60401730d9e9a20a4f681f10d0dd6b5b178f99.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\forall i } & { { } \\hat { s } _ { t } [ i ] \\geq \\hat { s } ^ { * } [ i ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            437,
+            606,
+            558,
+            625
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows the action space of different unit types controlled by the agent. The number of possible action is the same for all units since they controlled by a single model (unit type is encoded in the observation), but the meaning of actions differ according to unit type. An empty cell mean that the unit does nothing (nothing is sent to StarCraft, so the previous action persists). ",
+        "bbox": [
+            173,
+            641,
+            825,
+            699
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The more complexes actions “mine minerals”, “build a barracks”, “build a supply depot” have the following semantics, respectively: mine the mineral closest to the current unit, build a barracks at the position of the current unit, build a supply depot on the position of the current unit. ",
+        "bbox": [
+            174,
+            704,
+            825,
+            747
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Some actions are ignored under certain conditions: “mining” action is ignored if the distance to the closest mineral is greater than 12; “switch to Bob” is ignored if Bob is already in control; “building” and “training” actions are ignored if there is not enough resources; the actions that create a new SCV or a barracks are ignored if the number of active units is reached the limit of 10. Also “build” actions will be ignored if there is not enough room to build at the unit’s location. ",
+        "bbox": [
+            174,
+            753,
+            825,
+            824
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For the count-based exploration, we gave an extra reward of $\\alpha / \\sqrt { N ( \\hat { s _ { t } } ) }$ at every step, where $N$ is the visit count function and $\\hat { s _ { t } }$ is a global observation. We found $\\alpha = 0 . 1$ to be works the best. ",
+        "bbox": [
+            176,
+            830,
+            820,
+            861
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 9 we show the result of an additional experiment where we extended the length of the episode from 200 to 300, giving more time to the agent for development. The self-play still outperforms baselines methods. Note that to make more than 6 marines, an agent has to build a supply depot as well as a barracks. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/eeb7bf8cf5b98404b925b939ab3deeb3fdfaa1950f2ad1c0354f300c0369bd95.jpg",
+        "table_caption": [
+            "Table 2: Action space of different unit types in StarCraft. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Action ID</td><td rowspan=1 colspan=1>SCV</td><td rowspan=1 colspan=1>Command center</td><td rowspan=1 colspan=1>Barraks</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>move to right</td><td rowspan=1 colspan=1>train SCV</td><td rowspan=1 colspan=1>trainamarine</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>move to left</td><td rowspan=1 colspan=1>switch to Bob</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>move to top</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>move to bottom</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>mine minerals</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>build a barracks</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>build a supply depot</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr></table>",
+        "bbox": [
+            256,
+            101,
+            740,
+            220
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/c530d592ad4225a204dc121b42651ffab7d714d60c8b59ff42a8c8e545970c76.jpg",
+        "image_caption": [
+            "Figure 9: Plot of reward on the StarCraft sub-task of training where episode length $t _ { \\mathrm { M a x } }$ is increased to 300. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            310,
+            292,
+            699,
+            436
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "F FURTHER DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            518,
+            397,
+            535
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "F.1 META-EXPLORATION FOR ALICE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            554,
+            442,
+            568
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We want Alice and Bob to explore the state (or state-action) space, and we would like Bob to be exposed to many different tasks. Because of the form of the standard reinforcement learning objective (expectation over rewards), Alice only wants to find the single hardest thing for Bob, and is not interested in the space of things that are hard for Bob. In the fully tabular setting, with fully reversible dynamics or with resetting, and without the constraints of realistic optimization strategies, we saw in section 2.2 that this ends up forcing Bob and Alice to learn to make any state transition as efficiently as possible. However, with more realistic optimization methods or environments, and with function approximation, Bob and Alice can get stuck in sub-optimal minima. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            694
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For example, let us follow the argument in the third paragraph of Sec. 2.2, and assume that Bob and Alice are at an equilibrium (and that we are in the tabular, finite, Markovian setting), but now we can only update Bob’s and Alice’s policy locally. By this we mean that in our search for a better policy for Bob or Alice, we can only make small perturbations, as in policy gradient algorithms. In this case, we can only guarantee that Bob runs a fast policy on challenges that Alice has non-zero probability of giving; but there is no guarantee that Alice will cover all possible challenges. With function approximation instead of tabular policies, we cannot make any guarantees at all. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            797
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Another example with a similar outcome but different mechanism can occur using the reverse game in an environment without fully reversible dynamics. In that case, it could be that the shortest expected number of steps to complete a challenge $\\left( { { s } _ { 0 } } , { { s } _ { T } } \\right)$ is longer than the reverse, and indeed, so much longer that Alice should concentrate all her energy on this challenge to maximize her rewards. Thus there could be equilibria with Bob matching the fast policy only for a subset of challenges even if we allow non-local optimization. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            888
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The result is that Alice can end up in a policy that is not ideal for our purposes. In figure 8 we show the distributions of where Alice cedes control to Bob in the swimmer task. We can see that Alice has a preferred direction. Ideally, in this environment, Alice would be teaching Bob how to get from any state to any other efficiently; but instead, she is mostly teaching him how to move in one direction. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "One possible approach to correcting this is to have multiple Alices, regularized so that they do not implement the same policy. More generally, we can investigate objectives for Alice that encourage her to cover a wider distribution of behaviors. ",
+        "bbox": [
+            176,
+            138,
+            823,
+            180
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "F.2 COMMUNICATING VIA ACTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            198,
+            434,
+            212
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In this work we have limited Alice to propose tasks for Bob by doing them. This limitation is practical and effective in restricted environments that allow resetting or are (nearly) reversible. It allows a solution to three of the key difficulties of implementing the basic idea of “Alice proposes tasks, Bob does them”: parameterizing the sampling of tasks, representing and communicating the tasks, and ensuring the appropriate level of difficulty of the tasks. Each of these is interesting in more general contexts. In this work, the tasks have incentivized efficient transitions. One can imagine other reward functions and task representations that incentivize discovering statistics of the states and state-transitions, for example models of their causality or temporal ordering, cluster structure. ",
+        "bbox": [
+            174,
+            223,
+            825,
+            335
+        ],
+        "page_idx": 15
+    }
+]

parse/train/SyNPk2R9K7/SyNPk2R9K7.md

@@ -0,0 +1,260 @@
+# LEARNING TO DESCRIBE SCENES WITH PROGRAMS
+
+Yunchao Liu∗ IIIS, Tsinghua University
+
+Zheng Wu MIT CSAIL, Shanghai Jiao Tong University
+
+Daniel Ritchie Brown University
+
+William T. Freeman MIT CSAIL, Google Research
+
+Joshua B. Tenenbaum MIT CSAIL
+
+Jiajun Wu MIT CSAIL
+
+# ABSTRACT
+
+Human scene perception goes beyond recognizing a collection of objects and their pairwise relations. We understand higher-level, abstract regularities within the scene such as symmetry and repetition. Current vision recognition modules and scene representations fall short in this dimension. In this paper, we present scene programs, representing a scene via a symbolic program for its objects, attributes, and their relations. We also propose a model that infers such scene programs by exploiting a hierarchical, object-based scene representation. Experiments demonstrate that our model works well on synthetic data and transfers to real images with such compositional structure. The use of scene programs has enabled a number of applications, such as complex visual analogy-making and scene extrapolation.
+
+# 1 INTRODUCTION
+
+When examining the image in Figure 1a, we instantly recognize the shape, color, and material of the objects it depicts. We can also effortlessly imagine how we may extrapolate the set of objects in the scene while preserving object patterns (Figure 1b). Our ability to imagine unseen objects arises from holistic scene perception: we not only recognize individual objects from an image, but naturally perceive how they should be organized into higher-level structure (Rock & Palmer, 1990).
+
+Recent AI systems for scene understanding have made impressive progress on detecting, segmenting, and recognizing individual objects (He et al., 2017). In contrast, the problem of understanding high-level, abstract relations among objects is less studied. While a few recent papers have attempted to produce a holistic scene representation for scenes with a variable number of objects (Ba et al., 2015; Huang & Murphy, 2015; Eslami et al., 2016; Wu et al., 2017), the relationships among these objects are not captured in these models.
+
+The idea of jointly discovering objects and their relations has been explored only very recently, where the learned relations are often in the form of interaction graphs (van Steenkiste et al., 2018; Kipf et al., 2018) or semantic scene graphs (Johnson et al., 2015), both restricted to pairwise, local relations. However, our ability to imagine extrapolated images as in Figure 1 relies on our knowledge of long-range, hierarchical relationships among objects, such as how objects are grouped and what patterns characterize those groups.
+
+In this paper, we aim to tackle the problem of understanding higher-level, abstract regularities such as repetition and symmetry. We propose to represent scenes as scene programs. We define a domainspecific language for scenes, capturing both objects with their geometric and semantic attributes, as well as program commands such as loops to enforce higher-level structural relationships. Given an image of a complex scene, we propose to infer its scene program via a hierarchical bottom-up approach. First, we parse the image into individual objects and infer their attributes, resulting in the object representation. Then, we organize these objects into different groups, i.e. the group representation, where objects in each group fall into the same program block. Finally, we describe each group with a program, and combine these programs to get the program representation for the entire scene.
+
+![](images/f902a269648a531e1f52c1da2fd190b7194daa318fbcd47ea35ea16d3440a4ad.jpg)  
+Figure 1: High-level scene understanding. Given original image (a), we are able to imagine unseen objects based on the structural relations among existing objects, resulting in extrapolated image (b).
+
+Our model applies deep neural networks for each stage of this process and is able to generate programs describing the input image with high accuracy. When testing on scenes that are more complex than those used for training, our hierarchical inference process achieves better generalization performance than baseline methods that attempt to infer a program directly from the image. Our model is also able to handle ambiguity, generating multiple possible programs when there is more than one way to describe the scene. Furthermore, our method generalizes to real-world images without any additional supervised training programs; only the low-level object detection module must be re-trained. Finally, we demonstrate how our model facilitates high-level image editing, as users can change parameters in the inferred program to achieve the editing effects they want more efficiently. We show examples of such image edits, including extrapolations such as the one in (Figure 1b), on both synthetic and photographic images.
+
+Our contributions are therefore three-fold:
+
+1. We propose scene programs: a new representation for scenes, drawing insights from classic findings in cognitive science and computer graphics.   
+2. We present a method for inferring scene programs from images using a hierarchical approach (from objects to groups to programs).   
+3. We demonstrate that our model can achieve high accuracy on describing both synthetic and constrained real scenes with programs. Combined with modern image-to-image translation methods, our model generates realistic images of extrapolated scenes, capturing both highlevel scene structure and low-level object appearance.
+
+# 2 RELATED WORK
+
+Describing Images with Programs Ellis et al. (2018) performs a similar task as ours where handdrawn images of 2D geometry primitives are converted to high-level programs. This work uses a constraint-based SAT solver to perform program search and is much slower than neural network models. IM2LATEX (Deng et al., 2017) de-renders images into low-level $\mathrm { { I A I R } X }$ markup using a neural network, while our work discovers high-level programs from an image of objects. SPIRAL (Ganin et al., 2018) uses reinforcement learning to infer a sequence of low-level drawing commands that can reproduce an image, meanwhile learning a distribution from which images can be sampled. Beltramelli (2018) learns to convert GUI images to markup-like code. Unlike these papers, our model performs program induction in 3D and infers high-level structural patterns both in object layout and color.
+
+Describing the Structure of 3D Shapes and Scenes Beyond 2D images, prior work in vision and graphics has attempted to infer high-level structure from 3D objects and 3D scenes. The most relevant to our approach are those that extract a so-called symmetry hierarchy, in which 3D geometry is hierarchically grouped by either attachment or symmetric relationships (Wang et al., 2011). This representation has been used to train generative models of 3D shapes (Li et al., 2017) and indoor 3D scenes (Li et al., 2019), as well as to infer a hierarchical bounding box structure from a single image of a 3D shape (Niu et al., 2018). Our program representation bears some resemblance to the symmetry hierarchy, but it generalizes to repetitive patterns beyond symmetries and also models patterns in object visual attributes (e.g., color). CSGNet (Sharma et al., 2018) learns to parse shapes with a set of primitive and arithmetic commands; Tulsiani et al. (2017) parses shapes into an assembly of geometric primitives. In this paper, we focus on learning the high-level scene regularities described by loop structures.
+
+![](images/56ef2291bb5a15f2859f129d00130db7e0162e44573e4f66cb0183a4d11cad53.jpg)  
+Figure 2: Our model for visual program synthesis. (a) The input is an image consisting of multiple objects with ordered arrangements. We also perform instance segmentation to get object masks. (b) We use two vision models to extract object attributes and predict object groups, respectively. (c) These representations are then sent to a sequence model to predict the program.
+
+Neural Program Synthesis In general, a program synthesis model outputs an explicit program by learning from examples. Recent works on neural program synthesis include R3NN (Parisotto et al., 2017) and RobustFill (Devlin et al., 2017), which perform end-to-end program synthesis from input/output examples. Bunel et al. (2018) goes beyond the pure supervised learning setting and improves performance on diversity and syntax by leveraging grammar and reinforcement learning. These models synthesize programs based on input/output pairs, which is different from our setting, where a program is generated to describe an input image. In the vision domain, Sun et al. (2018) learns decision strategies represented as programs from demonstration videos, while we focus on describing the complex correlations among objects in static scenes.
+
+# 3 METHOD
+
+Our model combines vision and sequence models via structured representations. An object parser predicts the segmentation mask and attributes for each object in the image. A group recognizer predicts the group that each object belongs to. Finally, a program synthesizer generates a program block for each object group. Figure 2 shows an example of synthesizing programs from an input image, where a sphere is selected at random (highlighted) and the group that this object belongs to is predicted, which consists of six spheres. Then the program for this group (highlighted) is synthesized.
+
+# 3.1 A DOMAIN-SPECIFIC LANGUAGE (DSL) FOR SCENES
+
+In order to constrain the program space to make it tractable for our models, we introduce human prior on scene regularities that can be described as programs. More specifically, we introduce a Domain Specific Language (DSL) which explicitly defines the space of our scene programs. We present the grammar of our DSL in Table 1, which contains 3 primitive commands (cube, sphere, cylinder) and 2 loop structures (for, rotate). The positions for each object are defined as affine transformations of loop indices, while the colors are more complicated functions of the loop indices, displaying alternating (modular) and repeating (division) patterns.
+
+Furthermore, since the DSL allows unbounded program depth, we define program blocks to further reduce complexity. Each type of program block is an production instance of the Statement token, and objects that belong to the same block form a group. For example, in this work the program blocks include single objects, layered for loops of depth $\leq 3$ , and single-layer rotations of $\leq 4$ objects.
+
+Table 1: Grammar of the scene program. Primitive commands (cube, sphere, cylinder) can be placed inside loop structures, where the position and color of each object are determined by the loop indices.   
+
+<table><tr><td>Program →</td><td>Statement; ···; Statement</td></tr><tr><td>Statement</td><td></td></tr><tr><td></td><td>Cube(pos=Expression1,color=Expression2) sphere(pos=Expression1,color=Expression2)</td></tr><tr><td>Statement Statement</td><td>cylinder(pos=Expression1,color=Expression2)</td></tr><tr><td></td><td>for(0 ≤Varl &lt;Expression1){Program}</td></tr><tr><td>Statement Statement</td><td>rotate(O ≤ Var1 &lt; Expression1,start=Z,center=(Z,Z,Z)){Program}</td></tr><tr><td>Expression1</td><td></td><td>Z ×Var1+·+Z ×Var1+ Z</td></tr><tr><td>Expression2</td><td>→ →</td><td>Z × Var2+· + Z × Var2+ Z</td></tr><tr><td>Var1</td><td>→</td><td>a free variable</td></tr><tr><td>Var2</td><td></td><td>Var1|Var1 % Z|Var1 / Z</td></tr><tr><td>Z</td><td>→</td><td>integer</td></tr></table>
+
+# 3.2 OBJECT PARSING
+
+Following the spirit of The Trace Hypothesis (Ellis et al., 2018), we use object attributes as an intermediate representation between image space and structured program space. Parsing individual objects from the input image consists of two steps: mask prediction and attribute prediction. For each object, its instance segmentation mask is predicted by a Mask R-CNN (He et al., 2017). Next, the mask is concatenated with the original image, and sent to a ResNet-34 (He et al., 2015) to predict object attributes. In our work, object attributes include shape, size, material, color and 3D coordinates. Each attribute is encoded as a one-hot vector, except for coordinates. The overall representation of an object is a vector of length 18. The networks are trained with ground truth masks and attributes, respectively. For the attribute network, we minimize the mean-squared error between output and ground truth attributes.
+
+# 3.3 GROUP DETECTION
+
+When we identify a distinct visual pattern, we first know which objects in the image form the pattern before we can tell what the pattern is. Motivated by this idea, we develop a group recognizer that tells us which objects form a group that can be described by a single program block. The group recognizer works after mask prediction is performed, and answers the following specific question: given an input object, which objects are in the same group with this object?
+
+The input to the model consists of three parts: the original image, the mask of the input object, and the mask of all objects. These three parts are concatenated and sent to a ResNet-152 followed by fully connected layers. The output contains two parts: a binary vector $g$ where $g [ i ] = 1$ denotes object $i$ in the same group with the input object, and the category $c$ of the group, representing the type of program block that this group belongs to. The network is trained to minimize the binary cross entropy loss for group recognition, and the cross entropy loss for category classification.
+
+# 3.4 NEURAL PROGRAM SYNTHESIS
+
+With the object attributes and groups obtained from the vision models, the final step in our model is to generate program sequences describing the input image. Since we have already detected object groups, what remains is to generate a program block for each group. For this goal we train a sequence to sequence (seq2seq) LSTM with an encoder-decoder structure and attention mechanism (Luong et al., 2015; Bahdanau et al., 2015). The input sequence is a set of object attributes that form a group, which are sorted by their 3D coordinates. The output program consists of two parts: program tokens are predicted as a sequence as in neural machine translation, and program parameters are predicted by a MLP from the hidden state at each time step. At each step, we predict a token $t$ as well as a
+
+Result: a program sequence $P$   
+Input: a set of object attributes $O$ ;   
+while $O$ is not empty do randomly choose $o _ { i } \in O$ ; predict the group that contains $o _ { i }$ , indexed by $G$ ; also predict the group category $c$ ; get attributes of objects that belong to the group, $A = \{ o _ { j } | j \in G \}$ ; remove $A$ from $O$ ; send $A , c$ to program synthesizer, get program $p$ ; add $p$ to $P$ ;   
+end
+
+parameter matrix $P$ , which contains predicted parameters for all possible tokens. Then we use $P [ t ]$ as the output parameter for this step.
+
+Since the program synthesizer only works for a single group, a method for combining the group prediction with program synthesis is needed. Consider the simplest case where we randomly choose an object and describe the group it belongs to. This procedure is described in Algorithm 1. In practice, by default we sample 10 times and stop when a correct program is generated. Here correct means that we can recover the scene attributes successfully by executing the program.
+
+# 4 EXPERIMENTS
+
+We perform several experiments on synthetic scene images, including quantitative comparison with baseline methods and further extensions and applications. We further demonstrate our model’s ability to generalize to real images with a small amount of hand-labeled supervision which is only at the object level. We also apply our method to other tasks, specifically image extrapolation and visual analogy-making, on both synthetic and real images.
+
+# 4.1 DATASET
+
+We create a synthetic dataset of images rendered from complex scenes with rich program structures. Figure 3 displays some examples drawn from the dataset. These images are generated by first sampling scenes and then rendering using the same renderer as in CLEVR (Johnson et al., 2017). Each scene consists of a few groups, where objects in the same group can be described by a program block. The groups are sampled from predefined program primitives with multi-layered translational and rotational symmetries. Further, we also incorporate rich color patterns into the primitives.
+
+Our synthetic dataset includes annotations on object attributes and programs. We train and test the models on two synthetic datasets, REGULAR and RANDOM, each containing 20,000 training and 500 test images, where each image has at most 2 groups of multiple objects, in addition to many groups of a single object. In the REGULAR dataset (Figure 3a), the objects are placed on a grid and have discrete coordinates. We increase the scene complexity by adding randomness in the RANDOM dataset (Figure 3c), where objects are placed uniformly at random with continuous coordinates and different sizes.
+
+# 4.2 VISUAL PROGRAM SYNTHESIS
+
+Setup. We present evaluation results on our synthetic dataset introduced above. We compare with an ablated version of our full model, where we use a simple search-based heuristic grouping method (HG) which does not require any training or any knowledge of the program patterns. The details of this method are presented in Appendix A. We also compare with two baselines. One removes group recognition and instead synthesizes programs from all object attributes (derender-LSTM). Another directly synthesizes programs from the input image in an end-to-end manner (CNN-LSTM). The model uses a CNN as encoder and a LSTM with attention as decoder. We use the same network architecture as in attention-based neural image captioning (Xu et al., 2015), except that the decoder predicts a token as well as a parameter matrix at each time step.
+
+![](images/416e55e8f8815d11745ee7250b9cd6bb942096a299bade96383eccfd8f2a8ec5.jpg)  
+Figure 3: Qualitative results for visual program synthesis. (a) Results on the REGULAR test set, where all objects are placed on a grid. (b) Results on the generalization test set which contains more complex scenes. (c) Results on the RANDOM test set, where objects have different sizes and the groups are placed with random continuous coordinates.
+
+Table 2: Comparing program synthesis performance with baseline methods. Evaluation metrics include program token accuracy, parameter MSE loss, and scene reconstruction accuracy on the test sets.   
+
+<table><tr><td>Model</td><td>Token (%)</td><td>Param. (MSE)</td><td>Test (%)</td><td>Generalization (%)</td><td>Random (%)</td></tr><tr><td>ours (full)</td><td>99.5</td><td>0.014</td><td>96.6</td><td>70.0</td><td>97.6</td></tr><tr><td>ours (HG)</td><td>99.5</td><td>0.014</td><td>92.4</td><td>63.0</td><td>94.8</td></tr><tr><td>derender-LSTM</td><td>97.5</td><td>0.080</td><td>87.6</td><td>14.0</td><td>64.4</td></tr><tr><td>CNN-LSTM</td><td>98.9</td><td>0.043</td><td>92.3</td><td>48.0</td><td>70.7</td></tr></table>
+
+We evaluate the models on both the REGULAR and the RANDOM test sets. For evaluation on generalization, we also create an additional test set of 100 images, where each image contains three groups of multiple objects. These images are more complex and harder to describe than those in training.
+
+Results. Figure 3 includes qualitative results generated by our model on all three test sets. Our model generates accurate results in the REGULAR setting and is able to recognize the two groups from neighbouring objects (Figure 3a). Although trained on images with two groups, our model can perform well when tested on images with three groups (Figure 3b). When objects are placed at random, our model can accurately recognize which objects form a regular pattern and describe them with programs (Figure 3c). For quantitative evaluation, we compute program token accuracy and parameter loss, defined as the percentage of correctly predicted tokens and the mean-squared error of parameter prediction, respectively. To evaluate the global performance of the generated program, we also compute reconstruction accuracy of the programs, defined as the percentage of programs that correctly reconstruct the original image. The reconstruction accuracy is evaluated on all three test sets.
+
+We present the test results in Table 2, where our model outperforms baseline methods in each of the metrics, and achieves good performance on generalization. Note that the deep grouping model outperforms the simple heuristic grouping method, as it learns from the data distribution specified by our program space. Also note that our model performs better on RANDOM, while the baselines do not perform as well. This is because our group detection model discovers groups among randomly placed objects better than among regularly placed objects, as it is easier to rule out outsiders when they look random.
+
+![](images/a2c313459353a153635b710ac4b795fdda80d9f328303f0e4d422add49f2d8ab.jpg)  
+Figure 4: Generating multiple possible programs.
+
+![](images/68f9e804266f2e229b32ca45c3ff2eacf33d78a5e6e4d24fbca7270efc0ea30b.jpg)  
+Figure 5: Inferring programs from partial observations. (Input Image) The input image contains objects that are fully or mostly occluded. (Partial Observation) Output of Mask R-CNN where we discard mask proposals that are too small. The highlighted objects form the observation of our model. (Program) Despite the noisy and incomplete input, our model can accurately predict programs that describe the image.
+
+Tackling ambiguous input. While our model can generate program representations for images with high accuracy, it can also generate multiple possible programs when the input is ambiguous. Figure 4 shows an example where the red group can be described by either a two-layer for loop or a rotation of 4 objects. Our hierarchical method allows explicit specification of group category. When executing Algorithm 1, instead of selecting the most confident group category, we search top 3 proposals, and execute the synthesized program block to decide if each proposal corresponds to a possible correct program. Figure 4 demonstrates programs generated by our model, while the baseline methods tend to collapse to one possible answer and is unable to generate others.
+
+Program synthesis from partial observations. Our model can also handle scenes where there are invisible (or hardly visible) objects. Figure 5 demonstrates how our model operates on these scenes. Given an input image, we generate object instance masks and remove those with area below a certain threshold, so that the remaining objects can be correctly recognized. These objects form the partial observation of our model, from which the program synthesizer generates a program block which correctly describes the scene, including (partially) occluded objects. The flexibility of the neural program synthesizer allows us to recognize the same program pattern given different partial observations. Consider the two examples at the bottom of Figure 5. They have different set of observations (8 and 6 objects on bottom left and right, respectively) due to the different distances, and our model is able to correctly recognize both of them.
+
+![](images/af4048826c7d2790f559bfb0675b4663177c9bab690777a250f0e413da739b8d.jpg)  
+Figure 6: Image Editing. Our model can be applied to edit images by inferring programs (a) and then operate on program space. Examples include image extrapolation (b, c) and attribute editing (d, e).
+
+# 4.3 IMAGE EDITING
+
+Image editing via program representation. With the expressive power of the program representation, our model can be applied to tasks that require a high-level structural knowledge of the scene. For example, when an image lies within the space defined by our DSL, it can be efficiently edited using the program representation generated by our model. Figure 6 shows some examples of image editing, where the input image (Figure 6a) is represented by a program. Users can then edit the program to achieve the preferred editing effects. The edited program is sent to a graphics engine to render the new image. The structural form of our program representation allows various types of high-level editing, including spacial extrapolation (Figure 6b, c), changing color patterns (Figure 6d) and shapes (Figure 6e). Each of the four examples requires only one edit in the program, while using the traditional object representation, users have to change objects one at a time, averaging 6.25 edits per image.
+
+Real image extrapolation. An advantage of our method which uses object attributes as a connection between vision and program synthesis is to generalize to real images. Since our neural program synthesizer is independent from visual recognition, only the vision systems need to be retrained for our entire model to work on real images.
+
+Figure 7a shows images of LEGO blocks shot from a camera in real-world settings. We create a dataset of 120 real images, where we use 90 for training, 10 for validation, and 20 for testing. To adapt our model to generate programs for these images, we first pretrain on a synthetic dataset of 4,000 images rendered by a graphics engine. Then we fine-tune the model on 90 real images with labeled masks and attributes. The vision system is then linked with the pretrained program synthesizer which does not require any fine-tuning. Even with a small amount of real data for fine-tuning, our model generalizes well and correctly predicts the programs for each test image.
+
+Furthermore, the image editing techniques introduced above can also be applied to such real images. Here we present an experiment on real image extrapolation. Given an input image, we generate the program describing the image and also extract object patches with Mask R-CNN. The program is extended by increasing the iteration number, which is a simple way of “imagining” what could be the next given a sequence of observations.
+
+Our original method uses a graphics engine to render new images from edited programs (Figure 6), which is not applicable for real images. For this purpose, we use pix2pix (Isola et al., 2017) as an approximate neural renderer. After program inference, we execute the edited program and retrieve newly added object masks. These masks can be computed using camera parameters and 3D coordinates, while here we use retrieval for simplicity. All of the patches are pasted on a white background, and then sent to pix2pix to generate realistic background and lighting. Figure 7c displays the editing results. The edited images preserve object appearances in the original images, and also fix the errors made by mask prediction (small white gaps in Figure 7b) and contain realistic-looking shadows.
+
+![](images/6c2d23042edb61a08ea8f3e232011ac2f42aee8e7b234b63fa33bfb8c61b90b3.jpg)  
+Figure 7: Generalizing to real images. (a) Input image which is described by a program generated by our model. (b) The object patches in the original image are extracted using Mask R-CNN, while new objects are inferred by modifying the program iteration number and added as masks. (c) The edited image is rendered by pix2pix.
+
+<table><tr><td>Model</td><td>Synthetic</td><td>Real</td></tr><tr><td>Autoencoder</td><td>5.17</td><td>10.19</td></tr><tr><td>Ours</td><td>3.87</td><td>7.05</td></tr></table>
+
+Table 3: Average L2 distance between ground truth images and model outputs for visual analogy making experiment.
+
+# 4.4 VISUAL ANALOGY MAKING
+
+Besides representing images for efficient editing, scene programs can also be used as encoded images. For example, the distance in program space can also be applied to model similarity between images, which is already introduced by (Ellis et al., 2018). Motivated by this idea, we consider visual analogy making (Reed et al., 2015), where an input image is converted to a new image given other reference images. We introduce a setting where the reference is an image pair and ask the intuitive question, $i f$ B follows A, then what should follow C?
+
+Here we use a simple solution based on representation distance. More specifically, for an encoder $R$ and an input image $c$ with reference pair $( a , b )$ , we set $R ( d ) = R ( c ) + \bar { R ( b ) } - R ( \bar { a } )$ and decode $R ( d )$ to get the output. In our case, the encoder is our program synthesis model, while we use pix2pix as a neural decoder. In order to perform arithmetic operations, the program is represented as a matrix, where each line starts with a token followed by parameters (see Appendix A.3 for details). We compare our model with an autoencoder (Hinton $\&$ Salakhutdinov, 2006). The autoencoder we adopt takes an input image of size $2 5 6 \times 2 5 6$ , encodes the input into a 256-dimensional vector and then decodes the encoded vector back to original image size.
+
+Figure 8 shows qualitative results of the visual analogy making task. Using our program representation, our model generates perceptually plausible results (Figure 8e). While the autoencoder can sometimes correctly change the number of objects, it fails to preserve the layout arrangements (Figure 8f). We also compute the average L2 distance between model output and ground truth images made by humans. Table 3 shows that our model generates images that are closer to the ground truth than the baseline.
+
+![](images/68bdc40b2ab3f738e0d77fe11a4247daf021ef2a681198029bc03952cbb1c0a4.jpg)  
+Figure 8: Visual Analogy Making. Given example image pairs (a), (b), the input image (c) is encoded with a representation, which is edited according to the example image pair. The edited representation is then decoded into a new image by our model (e) and an autoencoder (f), respectively. (d) shows analogy making result made by human.
+
+# 5 CONCLUSION
+
+We propose scene programs as a structured representation of complex scenes with high-level regularities. We also present a novel method that infers scene programs from 2D images in a hierarchical bottom-up manner. Our model achieves high accuracy on a synthetic dataset and also generalizes to real images. The representation power of programs allows our model to be applied to other tasks in computer vision, such as image editing and analogy making, on both synthetic and photographic images.
+
+Acknowledgements. We thank Jiayuan Mao for insightful discussions and anonymous reviewers for their helpful feedback. This work was supported in part by NSF #1231216, NSF #1447476, NSF #1753684, ONR MURI N00014-16-1-2007, Facebook, and the Yao Class Exchange Program at IIIS, Tsinghua University.
+
+# REFERENCES
+
+Jimmy Ba, Volodymyr Mnih, and Koray Kavukcuoglu. Multiple object recognition with visual attention. In ICLR, 2015.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In ICLR, 2015.
+
+Tony Beltramelli. Pix2code: Generating code from a graphical user interface screenshot. In ACM SIGCHI Symposium on Engineering Interactive Computing Systems, EICS, 2018.
+
+Rudy Bunel, Matthew Hausknecht, Jacob Devlin, Rishabh Singh, and Pushmeet Kohli. Leveraging grammar and reinforcement learning for neural program synthesis. In ICLR, 2018.
+
+Yuntian Deng, Anssi Kanervisto, Jeffrey Ling, and Alexander M Rush. Image-to-markup generation with coarse-to-fine attention. In ICML, 2017.
+
+Jacob Devlin, Jonathan Uesato, Surya Bhupatiraju, Rishabh Singh, Abdel-rahman Mohamed, and Pushmeet Kohli. Robustfill: Neural program learning under noisy i/o. In ICML, 2017.
+
+Kevin Ellis, Daniel Ritchie, Armando Solar-Lezama, and Josh Tenenbaum. Learning to infer graphics programs from hand-drawn images. In NeurIPS, 2018.
+
+SM Eslami, Nicolas Heess, Theophane Weber, Yuval Tassa, Koray Kavukcuoglu, and Geoffrey E Hinton. Attend, infer, repeat: Fast scene understanding with generative models. In NeurIPS, 2016.
+
+Yaroslav Ganin, Tejas Kulkarni, Igor Babuschkin, S. M. Ali Eslami, and Oriol Vinyals. Synthesizing programs for images using reinforced adversarial learning. In ICML, 2018.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2015.
+
+Kaiming He, Georgia Gkioxari, Piotr Dollar, and Ross Girshick. Mask r-cnn. In ´ ICCV, 2017.
+
+Geoffrey E Hinton and Ruslan R Salakhutdinov. Reducing the dimensionality of data with neural networks. Science, 313(5786):504–507, 2006.
+
+Jonathan Huang and Kevin Murphy. Efficient inference in occlusion-aware generative models of images. In ICLR Workshop, 2015.
+
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. In CVPR, 2017.
+
+Justin Johnson, Ranjay Krishna, Michael Stark, Li-Jia Li, David Shamma, Michael Bernstein, and Li Fei-Fei. Image retrieval using scene graphs. In CVPR, 2015.
+
+Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C Lawrence Zitnick, and Ross Girshick. Clevr: A diagnostic dataset for compositional language and elementary visual reasoning. In CVPR, 2017.
+
+Thomas N Kipf, Ethan Fetaya, Kuan-Chieh Wang, Max Welling, and Richard S Zemel. Neural relational inference for interacting systems. In ICML, 2018.
+
+Jun Li, Kai Xu, Siddhartha Chaudhuri, Ersin Yumer, Hao Zhang, and Leonidas Guibas. GRASS: Generative Recursive Autoencoders for Shape Structures. In SIGGRAPH, 2017.
+
+Manyi Li, Akshay Gadi Patil, Kai Xu, Siddhartha Chaudhuri, Owais Khan, Ariel Shamir, Changhe Tu, Baoquan Chen, Daniel Cohen-Or, and Hao Zhang. Grains: Generative recursive autoencoders for indoor scenes. ACM TOG, 38(2):12:1–12:16, 2019.
+
+Thang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches to attention-based neural machine translation. In EMNLP, 2015.
+
+Chengjie Niu, Jun Li, and Kai Xu. Im2Struct: Recovering 3D Shape Structure from a Single RGB Image. In CVPR, 2018.
+
+Emilio Parisotto, Abdel-rahman Mohamed, Rishabh Singh, Lihong Li, Dengyong Zhou, and Pushmeet Kohli. Neuro-symbolic program synthesis. In ICLR, 2017.
+
+Scott E Reed, Yi Zhang, Yuting Zhang, and Honglak Lee. Deep visual analogy-making. In NeurIPS, 2015.
+
+Irvin Rock and Stephen Palmer. The legacy of gestalt psychology. Sci. Amer., 263(6):84–91, 1990.
+
+Gopal Sharma, Rishabh Goyal, Difan Liu, Evangelos Kalogerakis, and Subhransu Maji. Csgnet: Neural shape parser for constructive solid geometry. In CVPR, 2018.
+
+Shao-Hua Sun, Hyeonwoo Noh, Sriram Somasundaram, and Joseph Lim. Neural program synthesis from diverse demonstration videos. In ICML, 2018.
+
+Shubham Tulsiani, Hao Su, Leonidas J. Guibas, Alexei A. Efros, and Jitendra Malik. Learning shape abstractions by assembling volumetric primitives. In CVPR, 2017.
+
+Sjoerd van Steenkiste, Michael Chang, Klaus Greff, and Jurgen Schmidhuber. Relational neural ¨ expectation maximization: Unsupervised discovery of objects and their interactions. In ICLR, 2018.
+
+Yanzhen Wang, Kai Xu, Jun Li, Hao Zhang, Ariel Shamir, Ligang Liu, Zhi-Quan Cheng, and Yueshan Xiong. Symmetry Hierarchy of Man-Made Objects. Computer Graphics Forum, 2011.
+
+Jiajun Wu, Joshua B Tenenbaum, and Pushmeet Kohli. Neural scene de-rendering. In CVPR, 2017.
+
+Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhutdinov, Richard S Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In ICML, 2015.
+
+# A IMPLEMENTATION DETAILS
+
+# A.1 SCENE CONFIGURATION
+
+For synthetic data rendering, we use essentially the same settings as in CLEVR (Johnson et al., 2017). The objects are in two sizes (radius 0.4, 0.7), three shapes (sphere, cube, cylinder), two materials (metal, rubber), and eight colors (blue, brown, cyan, gray, green, purple, red, yellow). We represent the colors as numbers 1-8 in the scene programs as shown in Figure 3.
+
+In the REGULAR setting, objects are placed on a $5 \times 5 \times 5$ grid, with integer coordinates in 0-4, which means that the spacial gap between objects is a constant 1. We only use objects with the smaller size. Then we jitter each object position by a random noise sampled uniformly from $[ - 0 . 0 3 , 0 . 0 3 ]$ These random noises are used for visual diversity, and is ignored in the scene program.
+
+In the RANDOM setting, objects have both large and small sizes, and we use continuous coordinates in [0, 4]. When sampling a program block, the spacial gap between neighboring objects in the same group is still the constant 1, while the entire group is shifted by a continuous random amount. Finally, each object is also independently jittered by a random noise sampled uniformly from $[ - 0 . 0 3 , 0 . 0 3 ]$ .
+
+# A.2 HEURISTIC GROUPING
+
+We present the detailed method for heuristic grouping (HG) in Algorithm 2. Here $d ( o , G )$ denotes the minimum Euclidean distance from $o$ to any object in $G$ . During testing we will sample the distance threshold $\varepsilon$ multiple times.
+
+# A.3 DATA FORMAT FOR SCENE PROGRAMS
+
+In this Section we introduce the data format for the proposed scene programs. In short, a program is represented as a matrix, where each row contains a program command, which is a program token followed by its parameters. In our work, a program block is represented as a matrix of size $N \times 1 4$ where $N$ is the number of program commands. In order to unify the data format of the programs specified by our DSL defined in Table 1, we divide the 14 numbers into four parts: program token (index 0), iteration arguments (index 1-3), position arguments (index 4-6) and color arguments (index
+
+# Algorithm 2: A simple heuristic grouping algorithm
+
+Result: a group of objects $G$   
+Input: a set of object attributes $O$ , an object $o \in O$ ;   
+$G = \{ o \}$ ;   
+uniformly sample $\varepsilon$ from $[ 1 , { \sqrt { 2 } } ]$ ;   
+while True do for $o _ { i } \in O$ do if $o _ { i } \not \in G$ and $d ( o _ { i } , G ) < \varepsilon$ and $o _ { i }$ has the same shape as o then add $o _ { i }$ to $G$ end end if $G$ did not change in this iteration then return $G$ end   
+end
+
+7-13). We give an explicit example as shown in Figure 9. The matrix representation allows direct arithmetic operations in program space, which enables the application of scene programs in image analogy making (Figure 8).
+
+The evaluation of output program is different under different scene configurations. In the REGULAR setting, every program argument is an integer, so we round the output program to the nearest integer and calculate its accuracy. In the RANDOM setting, since the position arguments are continuous, we allow a small error (0.2) for them and treat the other arguments as integers.
+
+![](images/0c66edbf57386af7621fcd426b2cded2d44c58759c9c196a879a5b3da6f46502.jpg)  
+Figure 9: Data format of our scene programs. Each color represents a different type of argument, including red: program tokens, blue: iteration arguments, green: position arguments, purple: color arguments.

parse/train/SyNPk2R9K7/SyNPk2R9K7_content_list.json

@@ -0,0 +1,1436 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING TO DESCRIBE SCENES WITH PROGRAMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            795,
+            122
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yunchao Liu∗ IIIS, Tsinghua University ",
+        "bbox": [
+            184,
+            145,
+            351,
+            174
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zheng Wu MIT CSAIL, Shanghai Jiao Tong University ",
+        "bbox": [
+            377,
+            143,
+            669,
+            174
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Daniel Ritchie Brown University ",
+        "bbox": [
+            694,
+            145,
+            813,
+            174
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "William T. Freeman MIT CSAIL, Google Research ",
+        "bbox": [
+            184,
+            194,
+            387,
+            222
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Joshua B. Tenenbaum MIT CSAIL ",
+        "bbox": [
+            455,
+            194,
+            611,
+            222
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jiajun Wu MIT CSAIL ",
+        "bbox": [
+            678,
+            195,
+            763,
+            222
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            260,
+            544,
+            273
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Human scene perception goes beyond recognizing a collection of objects and their pairwise relations. We understand higher-level, abstract regularities within the scene such as symmetry and repetition. Current vision recognition modules and scene representations fall short in this dimension. In this paper, we present scene programs, representing a scene via a symbolic program for its objects, attributes, and their relations. We also propose a model that infers such scene programs by exploiting a hierarchical, object-based scene representation. Experiments demonstrate that our model works well on synthetic data and transfers to real images with such compositional structure. The use of scene programs has enabled a number of applications, such as complex visual analogy-making and scene extrapolation. ",
+        "bbox": [
+            233,
+            292,
+            766,
+            433
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            464,
+            336,
+            481
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "When examining the image in Figure 1a, we instantly recognize the shape, color, and material of the objects it depicts. We can also effortlessly imagine how we may extrapolate the set of objects in the scene while preserving object patterns (Figure 1b). Our ability to imagine unseen objects arises from holistic scene perception: we not only recognize individual objects from an image, but naturally perceive how they should be organized into higher-level structure (Rock & Palmer, 1990). ",
+        "bbox": [
+            174,
+            500,
+            825,
+            569
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent AI systems for scene understanding have made impressive progress on detecting, segmenting, and recognizing individual objects (He et al., 2017). In contrast, the problem of understanding high-level, abstract relations among objects is less studied. While a few recent papers have attempted to produce a holistic scene representation for scenes with a variable number of objects (Ba et al., 2015; Huang & Murphy, 2015; Eslami et al., 2016; Wu et al., 2017), the relationships among these objects are not captured in these models. ",
+        "bbox": [
+            174,
+            577,
+            825,
+            660
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The idea of jointly discovering objects and their relations has been explored only very recently, where the learned relations are often in the form of interaction graphs (van Steenkiste et al., 2018; Kipf et al., 2018) or semantic scene graphs (Johnson et al., 2015), both restricted to pairwise, local relations. However, our ability to imagine extrapolated images as in Figure 1 relies on our knowledge of long-range, hierarchical relationships among objects, such as how objects are grouped and what patterns characterize those groups. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            751
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we aim to tackle the problem of understanding higher-level, abstract regularities such as repetition and symmetry. We propose to represent scenes as scene programs. We define a domainspecific language for scenes, capturing both objects with their geometric and semantic attributes, as well as program commands such as loops to enforce higher-level structural relationships. Given an image of a complex scene, we propose to infer its scene program via a hierarchical bottom-up approach. First, we parse the image into individual objects and infer their attributes, resulting in the object representation. Then, we organize these objects into different groups, i.e. the group representation, where objects in each group fall into the same program block. Finally, we describe each group with a program, and combine these programs to get the program representation for the entire scene. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            896
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/f902a269648a531e1f52c1da2fd190b7194daa318fbcd47ea35ea16d3440a4ad.jpg",
+        "image_caption": [
+            "Figure 1: High-level scene understanding. Given original image (a), we are able to imagine unseen objects based on the structural relations among existing objects, resulting in extrapolated image (b). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            103,
+            823,
+            279
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our model applies deep neural networks for each stage of this process and is able to generate programs describing the input image with high accuracy. When testing on scenes that are more complex than those used for training, our hierarchical inference process achieves better generalization performance than baseline methods that attempt to infer a program directly from the image. Our model is also able to handle ambiguity, generating multiple possible programs when there is more than one way to describe the scene. Furthermore, our method generalizes to real-world images without any additional supervised training programs; only the low-level object detection module must be re-trained. Finally, we demonstrate how our model facilitates high-level image editing, as users can change parameters in the inferred program to achieve the editing effects they want more efficiently. We show examples of such image edits, including extrapolations such as the one in (Figure 1b), on both synthetic and photographic images. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            512
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions are therefore three-fold: ",
+        "bbox": [
+            176,
+            520,
+            450,
+            534
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We propose scene programs: a new representation for scenes, drawing insights from classic findings in cognitive science and computer graphics.   \n2. We present a method for inferring scene programs from images using a hierarchical approach (from objects to groups to programs).   \n3. We demonstrate that our model can achieve high accuracy on describing both synthetic and constrained real scenes with programs. Combined with modern image-to-image translation methods, our model generates realistic images of extrapolated scenes, capturing both highlevel scene structure and low-level object appearance. ",
+        "bbox": [
+            210,
+            545,
+            825,
+            667
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            690,
+            344,
+            707
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Describing Images with Programs Ellis et al. (2018) performs a similar task as ours where handdrawn images of 2D geometry primitives are converted to high-level programs. This work uses a constraint-based SAT solver to perform program search and is much slower than neural network models. IM2LATEX (Deng et al., 2017) de-renders images into low-level $\\mathrm { { I A I R } X }$ markup using a neural network, while our work discovers high-level programs from an image of objects. SPIRAL (Ganin et al., 2018) uses reinforcement learning to infer a sequence of low-level drawing commands that can reproduce an image, meanwhile learning a distribution from which images can be sampled. Beltramelli (2018) learns to convert GUI images to markup-like code. Unlike these papers, our model performs program induction in 3D and infers high-level structural patterns both in object layout and color. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            862
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Describing the Structure of 3D Shapes and Scenes Beyond 2D images, prior work in vision and graphics has attempted to infer high-level structure from 3D objects and 3D scenes. The most relevant to our approach are those that extract a so-called symmetry hierarchy, in which 3D geometry is hierarchically grouped by either attachment or symmetric relationships (Wang et al., 2011). This representation has been used to train generative models of 3D shapes (Li et al., 2017) and indoor 3D scenes (Li et al., 2019), as well as to infer a hierarchical bounding box structure from a single image of a 3D shape (Niu et al., 2018). Our program representation bears some resemblance to the symmetry hierarchy, but it generalizes to repetitive patterns beyond symmetries and also models patterns in object visual attributes (e.g., color). CSGNet (Sharma et al., 2018) learns to parse shapes with a set of primitive and arithmetic commands; Tulsiani et al. (2017) parses shapes into an assembly of geometric primitives. In this paper, we focus on learning the high-level scene regularities described by loop structures. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/56ef2291bb5a15f2859f129d00130db7e0162e44573e4f66cb0183a4d11cad53.jpg",
+        "image_caption": [
+            "Figure 2: Our model for visual program synthesis. (a) The input is an image consisting of multiple objects with ordered arrangements. We also perform instance segmentation to get object masks. (b) We use two vision models to extract object attributes and predict object groups, respectively. (c) These representations are then sent to a sequence model to predict the program. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            102,
+            754,
+            257
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            358,
+            825,
+            469
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Neural Program Synthesis In general, a program synthesis model outputs an explicit program by learning from examples. Recent works on neural program synthesis include R3NN (Parisotto et al., 2017) and RobustFill (Devlin et al., 2017), which perform end-to-end program synthesis from input/output examples. Bunel et al. (2018) goes beyond the pure supervised learning setting and improves performance on diversity and syntax by leveraging grammar and reinforcement learning. These models synthesize programs based on input/output pairs, which is different from our setting, where a program is generated to describe an input image. In the vision domain, Sun et al. (2018) learns decision strategies represented as programs from demonstration videos, while we focus on describing the complex correlations among objects in static scenes. ",
+        "bbox": [
+            173,
+            478,
+            825,
+            603
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            626,
+            281,
+            642
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our model combines vision and sequence models via structured representations. An object parser predicts the segmentation mask and attributes for each object in the image. A group recognizer predicts the group that each object belongs to. Finally, a program synthesizer generates a program block for each object group. Figure 2 shows an example of synthesizing programs from an input image, where a sphere is selected at random (highlighted) and the group that this object belongs to is predicted, which consists of six spheres. Then the program for this group (highlighted) is synthesized. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            744
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 A DOMAIN-SPECIFIC LANGUAGE (DSL) FOR SCENES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            763,
+            586,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In order to constrain the program space to make it tractable for our models, we introduce human prior on scene regularities that can be described as programs. More specifically, we introduce a Domain Specific Language (DSL) which explicitly defines the space of our scene programs. We present the grammar of our DSL in Table 1, which contains 3 primitive commands (cube, sphere, cylinder) and 2 loop structures (for, rotate). The positions for each object are defined as affine transformations of loop indices, while the colors are more complicated functions of the loop indices, displaying alternating (modular) and repeating (division) patterns. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, since the DSL allows unbounded program depth, we define program blocks to further reduce complexity. Each type of program block is an production instance of the Statement token, and objects that belong to the same block form a group. For example, in this work the program blocks include single objects, layered for loops of depth $\\leq 3$ , and single-layer rotations of $\\leq 4$ objects. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/4b102d7412292a0df3714c606f8d2751ff0564b038d2dbc84cb869137b7dfff4.jpg",
+        "table_caption": [
+            "Table 1: Grammar of the scene program. Primitive commands (cube, sphere, cylinder) can be placed inside loop structures, where the position and color of each object are determined by the loop indices. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Program →</td><td>Statement; ···; Statement</td></tr><tr><td>Statement</td><td></td></tr><tr><td></td><td>Cube(pos=Expression1,color=Expression2) sphere(pos=Expression1,color=Expression2)</td></tr><tr><td>Statement Statement</td><td>cylinder(pos=Expression1,color=Expression2)</td></tr><tr><td></td><td>for(0 ≤Varl &lt;Expression1){Program}</td></tr><tr><td>Statement Statement</td><td>rotate(O ≤ Var1 &lt; Expression1,start=Z,center=(Z,Z,Z)){Program}</td></tr><tr><td>Expression1</td><td></td><td>Z ×Var1+·+Z ×Var1+ Z</td></tr><tr><td>Expression2</td><td>→ →</td><td>Z × Var2+· + Z × Var2+ Z</td></tr><tr><td>Var1</td><td>→</td><td>a free variable</td></tr><tr><td>Var2</td><td></td><td>Var1|Var1 % Z|Var1 / Z</td></tr><tr><td>Z</td><td>→</td><td>integer</td></tr></table>",
+        "bbox": [
+            179,
+            108,
+            810,
+            268
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            353,
+            823,
+            381
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 OBJECT PARSING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            398,
+            336,
+            412
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Following the spirit of The Trace Hypothesis (Ellis et al., 2018), we use object attributes as an intermediate representation between image space and structured program space. Parsing individual objects from the input image consists of two steps: mask prediction and attribute prediction. For each object, its instance segmentation mask is predicted by a Mask R-CNN (He et al., 2017). Next, the mask is concatenated with the original image, and sent to a ResNet-34 (He et al., 2015) to predict object attributes. In our work, object attributes include shape, size, material, color and 3D coordinates. Each attribute is encoded as a one-hot vector, except for coordinates. The overall representation of an object is a vector of length 18. The networks are trained with ground truth masks and attributes, respectively. For the attribute network, we minimize the mean-squared error between output and ground truth attributes. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            564
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 GROUP DETECTION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            582,
+            351,
+            595
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "When we identify a distinct visual pattern, we first know which objects in the image form the pattern before we can tell what the pattern is. Motivated by this idea, we develop a group recognizer that tells us which objects form a group that can be described by a single program block. The group recognizer works after mask prediction is performed, and answers the following specific question: given an input object, which objects are in the same group with this object? ",
+        "bbox": [
+            174,
+            608,
+            823,
+            678
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The input to the model consists of three parts: the original image, the mask of the input object, and the mask of all objects. These three parts are concatenated and sent to a ResNet-152 followed by fully connected layers. The output contains two parts: a binary vector $g$ where $g [ i ] = 1$ denotes object $i$ in the same group with the input object, and the category $c$ of the group, representing the type of program block that this group belongs to. The network is trained to minimize the binary cross entropy loss for group recognition, and the cross entropy loss for category classification. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            768
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 NEURAL PROGRAM SYNTHESIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            786,
+            433,
+            800
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "With the object attributes and groups obtained from the vision models, the final step in our model is to generate program sequences describing the input image. Since we have already detected object groups, what remains is to generate a program block for each group. For this goal we train a sequence to sequence (seq2seq) LSTM with an encoder-decoder structure and attention mechanism (Luong et al., 2015; Bahdanau et al., 2015). The input sequence is a set of object attributes that form a group, which are sorted by their 3D coordinates. The output program consists of two parts: program tokens are predicted as a sequence as in neural machine translation, and program parameters are predicted by a MLP from the hidden state at each time step. At each step, we predict a token $t$ as well as a ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Result: a program sequence $P$   \nInput: a set of object attributes $O$ ;   \nwhile $O$ is not empty do randomly choose $o _ { i } \\in O$ ; predict the group that contains $o _ { i }$ , indexed by $G$ ; also predict the group category $c$ ; get attributes of objects that belong to the group, $A = \\{ o _ { j } | j \\in G \\}$ ; remove $A$ from $O$ ; send $A , c$ to program synthesizer, get program $p$ ; add $p$ to $P$ ;   \nend ",
+        "bbox": [
+            173,
+            126,
+            637,
+            280
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "parameter matrix $P$ , which contains predicted parameters for all possible tokens. Then we use $P [ t ]$ as the output parameter for this step. ",
+        "bbox": [
+            174,
+            315,
+            821,
+            344
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since the program synthesizer only works for a single group, a method for combining the group prediction with program synthesis is needed. Consider the simplest case where we randomly choose an object and describe the group it belongs to. This procedure is described in Algorithm 1. In practice, by default we sample 10 times and stop when a correct program is generated. Here correct means that we can recover the scene attributes successfully by executing the program. ",
+        "bbox": [
+            174,
+            351,
+            825,
+            420
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            443,
+            326,
+            458
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We perform several experiments on synthetic scene images, including quantitative comparison with baseline methods and further extensions and applications. We further demonstrate our model’s ability to generalize to real images with a small amount of hand-labeled supervision which is only at the object level. We also apply our method to other tasks, specifically image extrapolation and visual analogy-making, on both synthetic and real images. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            546
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            565,
+            279,
+            580
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We create a synthetic dataset of images rendered from complex scenes with rich program structures. Figure 3 displays some examples drawn from the dataset. These images are generated by first sampling scenes and then rendering using the same renderer as in CLEVR (Johnson et al., 2017). Each scene consists of a few groups, where objects in the same group can be described by a program block. The groups are sampled from predefined program primitives with multi-layered translational and rotational symmetries. Further, we also incorporate rich color patterns into the primitives. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            675
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our synthetic dataset includes annotations on object attributes and programs. We train and test the models on two synthetic datasets, REGULAR and RANDOM, each containing 20,000 training and 500 test images, where each image has at most 2 groups of multiple objects, in addition to many groups of a single object. In the REGULAR dataset (Figure 3a), the objects are placed on a grid and have discrete coordinates. We increase the scene complexity by adding randomness in the RANDOM dataset (Figure 3c), where objects are placed uniformly at random with continuous coordinates and different sizes. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            780
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 VISUAL PROGRAM SYNTHESIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            799,
+            428,
+            814
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Setup. We present evaluation results on our synthetic dataset introduced above. We compare with an ablated version of our full model, where we use a simple search-based heuristic grouping method (HG) which does not require any training or any knowledge of the program patterns. The details of this method are presented in Appendix A. We also compare with two baselines. One removes group recognition and instead synthesizes programs from all object attributes (derender-LSTM). Another directly synthesizes programs from the input image in an end-to-end manner (CNN-LSTM). The model uses a CNN as encoder and a LSTM with attention as decoder. We use the same network architecture as in attention-based neural image captioning (Xu et al., 2015), except that the decoder predicts a token as well as a parameter matrix at each time step. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/416e55e8f8815d11745ee7250b9cd6bb942096a299bade96383eccfd8f2a8ec5.jpg",
+        "image_caption": [
+            "Figure 3: Qualitative results for visual program synthesis. (a) Results on the REGULAR test set, where all objects are placed on a grid. (b) Results on the generalization test set which contains more complex scenes. (c) Results on the RANDOM test set, where objects have different sizes and the groups are placed with random continuous coordinates. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            101,
+            862,
+            352
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/1dba4e75330abfcbdd9a82e3118b7da8e619b665a32fce214ff4f56c137ca019.jpg",
+        "table_caption": [
+            "Table 2: Comparing program synthesis performance with baseline methods. Evaluation metrics include program token accuracy, parameter MSE loss, and scene reconstruction accuracy on the test sets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Token (%)</td><td>Param. (MSE)</td><td>Test (%)</td><td>Generalization (%)</td><td>Random (%)</td></tr><tr><td>ours (full)</td><td>99.5</td><td>0.014</td><td>96.6</td><td>70.0</td><td>97.6</td></tr><tr><td>ours (HG)</td><td>99.5</td><td>0.014</td><td>92.4</td><td>63.0</td><td>94.8</td></tr><tr><td>derender-LSTM</td><td>97.5</td><td>0.080</td><td>87.6</td><td>14.0</td><td>64.4</td></tr><tr><td>CNN-LSTM</td><td>98.9</td><td>0.043</td><td>92.3</td><td>48.0</td><td>70.7</td></tr></table>",
+        "bbox": [
+            196,
+            457,
+            797,
+            542
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            626,
+            821,
+            654
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the models on both the REGULAR and the RANDOM test sets. For evaluation on generalization, we also create an additional test set of 100 images, where each image contains three groups of multiple objects. These images are more complex and harder to describe than those in training. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            717
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results. Figure 3 includes qualitative results generated by our model on all three test sets. Our model generates accurate results in the REGULAR setting and is able to recognize the two groups from neighbouring objects (Figure 3a). Although trained on images with two groups, our model can perform well when tested on images with three groups (Figure 3b). When objects are placed at random, our model can accurately recognize which objects form a regular pattern and describe them with programs (Figure 3c). For quantitative evaluation, we compute program token accuracy and parameter loss, defined as the percentage of correctly predicted tokens and the mean-squared error of parameter prediction, respectively. To evaluate the global performance of the generated program, we also compute reconstruction accuracy of the programs, defined as the percentage of programs that correctly reconstruct the original image. The reconstruction accuracy is evaluated on all three test sets. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We present the test results in Table 2, where our model outperforms baseline methods in each of the metrics, and achieves good performance on generalization. Note that the deep grouping model outperforms the simple heuristic grouping method, as it learns from the data distribution specified by our program space. Also note that our model performs better on RANDOM, while the baselines do not perform as well. This is because our group detection model discovers groups among randomly placed objects better than among regularly placed objects, as it is easier to rule out outsiders when they look random. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/a2c313459353a153635b710ac4b795fdda80d9f328303f0e4d422add49f2d8ab.jpg",
+        "image_caption": [
+            "Figure 4: Generating multiple possible programs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            102,
+            758,
+            212
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/68f9e804266f2e229b32ca45c3ff2eacf33d78a5e6e4d24fbca7270efc0ea30b.jpg",
+        "image_caption": [
+            "Figure 5: Inferring programs from partial observations. (Input Image) The input image contains objects that are fully or mostly occluded. (Partial Observation) Output of Mask R-CNN where we discard mask proposals that are too small. The highlighted objects form the observation of our model. (Program) Despite the noisy and incomplete input, our model can accurately predict programs that describe the image. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            275,
+            820,
+            446
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            577,
+            825,
+            632
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Tackling ambiguous input. While our model can generate program representations for images with high accuracy, it can also generate multiple possible programs when the input is ambiguous. Figure 4 shows an example where the red group can be described by either a two-layer for loop or a rotation of 4 objects. Our hierarchical method allows explicit specification of group category. When executing Algorithm 1, instead of selecting the most confident group category, we search top 3 proposals, and execute the synthesized program block to decide if each proposal corresponds to a possible correct program. Figure 4 demonstrates programs generated by our model, while the baseline methods tend to collapse to one possible answer and is unable to generate others. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            765
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Program synthesis from partial observations. Our model can also handle scenes where there are invisible (or hardly visible) objects. Figure 5 demonstrates how our model operates on these scenes. Given an input image, we generate object instance masks and remove those with area below a certain threshold, so that the remaining objects can be correctly recognized. These objects form the partial observation of our model, from which the program synthesizer generates a program block which correctly describes the scene, including (partially) occluded objects. The flexibility of the neural program synthesizer allows us to recognize the same program pattern given different partial observations. Consider the two examples at the bottom of Figure 5. They have different set of observations (8 and 6 objects on bottom left and right, respectively) due to the different distances, and our model is able to correctly recognize both of them. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/af4048826c7d2790f559bfb0675b4663177c9bab690777a250f0e413da739b8d.jpg",
+        "image_caption": [
+            "Figure 6: Image Editing. Our model can be applied to edit images by inferring programs (a) and then operate on program space. Examples include image extrapolation (b, c) and attribute editing (d, e). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            98,
+            823,
+            247
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 IMAGE EDITING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            342,
+            326,
+            356
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Image editing via program representation. With the expressive power of the program representation, our model can be applied to tasks that require a high-level structural knowledge of the scene. For example, when an image lies within the space defined by our DSL, it can be efficiently edited using the program representation generated by our model. Figure 6 shows some examples of image editing, where the input image (Figure 6a) is represented by a program. Users can then edit the program to achieve the preferred editing effects. The edited program is sent to a graphics engine to render the new image. The structural form of our program representation allows various types of high-level editing, including spacial extrapolation (Figure 6b, c), changing color patterns (Figure 6d) and shapes (Figure 6e). Each of the four examples requires only one edit in the program, while using the traditional object representation, users have to change objects one at a time, averaging 6.25 edits per image. ",
+        "bbox": [
+            173,
+            376,
+            825,
+            529
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Real image extrapolation. An advantage of our method which uses object attributes as a connection between vision and program synthesis is to generalize to real images. Since our neural program synthesizer is independent from visual recognition, only the vision systems need to be retrained for our entire model to work on real images. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            609
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 7a shows images of LEGO blocks shot from a camera in real-world settings. We create a dataset of 120 real images, where we use 90 for training, 10 for validation, and 20 for testing. To adapt our model to generate programs for these images, we first pretrain on a synthetic dataset of 4,000 images rendered by a graphics engine. Then we fine-tune the model on 90 real images with labeled masks and attributes. The vision system is then linked with the pretrained program synthesizer which does not require any fine-tuning. Even with a small amount of real data for fine-tuning, our model generalizes well and correctly predicts the programs for each test image. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            715
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, the image editing techniques introduced above can also be applied to such real images. Here we present an experiment on real image extrapolation. Given an input image, we generate the program describing the image and also extract object patches with Mask R-CNN. The program is extended by increasing the iteration number, which is a simple way of “imagining” what could be the next given a sequence of observations. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            791
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our original method uses a graphics engine to render new images from edited programs (Figure 6), which is not applicable for real images. For this purpose, we use pix2pix (Isola et al., 2017) as an approximate neural renderer. After program inference, we execute the edited program and retrieve newly added object masks. These masks can be computed using camera parameters and 3D coordinates, while here we use retrieval for simplicity. All of the patches are pasted on a white background, and then sent to pix2pix to generate realistic background and lighting. Figure 7c displays the editing results. The edited images preserve object appearances in the original images, and also fix the errors made by mask prediction (small white gaps in Figure 7b) and contain realistic-looking shadows. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6c2d23042edb61a08ea8f3e232011ac2f42aee8e7b234b63fa33bfb8c61b90b3.jpg",
+        "image_caption": [
+            "Figure 7: Generalizing to real images. (a) Input image which is described by a program generated by our model. (b) The object patches in the original image are extracted using Mask R-CNN, while new objects are inferred by modifying the program iteration number and added as masks. (c) The edited image is rendered by pix2pix. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            107,
+            821,
+            444
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/ae7e85ab274cd66f461d998bc3e85174200758a38ee4b9ca0c0d7d424c88c86d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Synthetic</td><td>Real</td></tr><tr><td>Autoencoder</td><td>5.17</td><td>10.19</td></tr><tr><td>Ours</td><td>3.87</td><td>7.05</td></tr></table>",
+        "bbox": [
+            382,
+            535,
+            611,
+            589
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Average L2 distance between ground truth images and model outputs for visual analogy making experiment. ",
+        "bbox": [
+            173,
+            606,
+            823,
+            635
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 VISUAL ANALOGY MAKING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            660,
+            411,
+            674
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Besides representing images for efficient editing, scene programs can also be used as encoded images. For example, the distance in program space can also be applied to model similarity between images, which is already introduced by (Ellis et al., 2018). Motivated by this idea, we consider visual analogy making (Reed et al., 2015), where an input image is converted to a new image given other reference images. We introduce a setting where the reference is an image pair and ask the intuitive question, $i f$ B follows A, then what should follow C? ",
+        "bbox": [
+            174,
+            686,
+            826,
+            770
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Here we use a simple solution based on representation distance. More specifically, for an encoder $R$ and an input image $c$ with reference pair $( a , b )$ , we set $R ( d ) = R ( c ) + \\bar { R ( b ) } - R ( \\bar { a } )$ and decode $R ( d )$ to get the output. In our case, the encoder is our program synthesis model, while we use pix2pix as a neural decoder. In order to perform arithmetic operations, the program is represented as a matrix, where each line starts with a token followed by parameters (see Appendix A.3 for details). We compare our model with an autoencoder (Hinton $\\&$ Salakhutdinov, 2006). The autoencoder we adopt takes an input image of size $2 5 6 \\times 2 5 6$ , encodes the input into a 256-dimensional vector and then decodes the encoded vector back to original image size. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 8 shows qualitative results of the visual analogy making task. Using our program representation, our model generates perceptually plausible results (Figure 8e). While the autoencoder can sometimes correctly change the number of objects, it fails to preserve the layout arrangements (Figure 8f). We also compute the average L2 distance between model output and ground truth images made by humans. Table 3 shows that our model generates images that are closer to the ground truth than the baseline. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/68bdc40b2ab3f738e0d77fe11a4247daf021ef2a681198029bc03952cbb1c0a4.jpg",
+        "image_caption": [
+            "Figure 8: Visual Analogy Making. Given example image pairs (a), (b), the input image (c) is encoded with a representation, which is edited according to the example image pair. The edited representation is then decoded into a new image by our model (e) and an autoencoder (f), respectively. (d) shows analogy making result made by human. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            103,
+            821,
+            448
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            568,
+            825,
+            622
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            648,
+            318,
+            664
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We propose scene programs as a structured representation of complex scenes with high-level regularities. We also present a novel method that infers scene programs from 2D images in a hierarchical bottom-up manner. Our model achieves high accuracy on a synthetic dataset and also generalizes to real images. The representation power of programs allows our model to be applied to other tasks in computer vision, such as image editing and analogy making, on both synthetic and photographic images. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            768
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements. We thank Jiayuan Mao for insightful discussions and anonymous reviewers for their helpful feedback. This work was supported in part by NSF #1231216, NSF #1447476, NSF #1753684, ONR MURI N00014-16-1-2007, Facebook, and the Yao Class Exchange Program at IIIS, Tsinghua University. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            834
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            859,
+            285,
+            876
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Ba, Volodymyr Mnih, and Koray Kavukcuoglu. Multiple object recognition with visual attention. In ICLR, 2015. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In ICLR, 2015. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tony Beltramelli. Pix2code: Generating code from a graphical user interface screenshot. In ACM SIGCHI Symposium on Engineering Interactive Computing Systems, EICS, 2018. ",
+        "bbox": [
+            174,
+            142,
+            823,
+            171
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rudy Bunel, Matthew Hausknecht, Jacob Devlin, Rishabh Singh, and Pushmeet Kohli. Leveraging grammar and reinforcement learning for neural program synthesis. In ICLR, 2018. ",
+        "bbox": [
+            173,
+            180,
+            821,
+            210
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuntian Deng, Anssi Kanervisto, Jeffrey Ling, and Alexander M Rush. Image-to-markup generation with coarse-to-fine attention. In ICML, 2017. ",
+        "bbox": [
+            173,
+            219,
+            821,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Jonathan Uesato, Surya Bhupatiraju, Rishabh Singh, Abdel-rahman Mohamed, and Pushmeet Kohli. Robustfill: Neural program learning under noisy i/o. In ICML, 2017. ",
+        "bbox": [
+            174,
+            258,
+            823,
+            289
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kevin Ellis, Daniel Ritchie, Armando Solar-Lezama, and Josh Tenenbaum. Learning to infer graphics programs from hand-drawn images. In NeurIPS, 2018. ",
+        "bbox": [
+            174,
+            297,
+            823,
+            327
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "SM Eslami, Nicolas Heess, Theophane Weber, Yuval Tassa, Koray Kavukcuoglu, and Geoffrey E Hinton. Attend, infer, repeat: Fast scene understanding with generative models. In NeurIPS, 2016. ",
+        "bbox": [
+            176,
+            337,
+            823,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yaroslav Ganin, Tejas Kulkarni, Igor Babuschkin, S. M. Ali Eslami, and Oriol Vinyals. Synthesizing programs for images using reinforced adversarial learning. In ICML, 2018. ",
+        "bbox": [
+            174,
+            375,
+            823,
+            405
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2015. ",
+        "bbox": [
+            173,
+            415,
+            823,
+            444
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Georgia Gkioxari, Piotr Dollar, and Ross Girshick. Mask r-cnn. In ´ ICCV, 2017. ",
+        "bbox": [
+            173,
+            452,
+            787,
+            469
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton and Ruslan R Salakhutdinov. Reducing the dimensionality of data with neural networks. Science, 313(5786):504–507, 2006. ",
+        "bbox": [
+            171,
+            478,
+            823,
+            507
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Huang and Kevin Murphy. Efficient inference in occlusion-aware generative models of images. In ICLR Workshop, 2015. ",
+        "bbox": [
+            169,
+            517,
+            825,
+            546
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            555,
+            823,
+            585
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Ranjay Krishna, Michael Stark, Li-Jia Li, David Shamma, Michael Bernstein, and Li Fei-Fei. Image retrieval using scene graphs. In CVPR, 2015. ",
+        "bbox": [
+            173,
+            594,
+            823,
+            625
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C Lawrence Zitnick, and Ross Girshick. Clevr: A diagnostic dataset for compositional language and elementary visual reasoning. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            633,
+            823,
+            678
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf, Ethan Fetaya, Kuan-Chieh Wang, Max Welling, and Richard S Zemel. Neural relational inference for interacting systems. In ICML, 2018. ",
+        "bbox": [
+            173,
+            686,
+            823,
+            717
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jun Li, Kai Xu, Siddhartha Chaudhuri, Ersin Yumer, Hao Zhang, and Leonidas Guibas. GRASS: Generative Recursive Autoencoders for Shape Structures. In SIGGRAPH, 2017. ",
+        "bbox": [
+            171,
+            724,
+            823,
+            755
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Manyi Li, Akshay Gadi Patil, Kai Xu, Siddhartha Chaudhuri, Owais Khan, Ariel Shamir, Changhe Tu, Baoquan Chen, Daniel Cohen-Or, and Hao Zhang. Grains: Generative recursive autoencoders for indoor scenes. ACM TOG, 38(2):12:1–12:16, 2019. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            808
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches to attention-based neural machine translation. In EMNLP, 2015. ",
+        "bbox": [
+            169,
+            816,
+            825,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chengjie Niu, Jun Li, and Kai Xu. Im2Struct: Recovering 3D Shape Structure from a Single RGB Image. In CVPR, 2018. ",
+        "bbox": [
+            173,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emilio Parisotto, Abdel-rahman Mohamed, Rishabh Singh, Lihong Li, Dengyong Zhou, and Pushmeet Kohli. Neuro-symbolic program synthesis. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Scott E Reed, Yi Zhang, Yuting Zhang, and Honglak Lee. Deep visual analogy-making. In NeurIPS, 2015. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Irvin Rock and Stephen Palmer. The legacy of gestalt psychology. Sci. Amer., 263(6):84–91, 1990. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            157
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gopal Sharma, Rishabh Goyal, Difan Liu, Evangelos Kalogerakis, and Subhransu Maji. Csgnet: Neural shape parser for constructive solid geometry. In CVPR, 2018. ",
+        "bbox": [
+            174,
+            165,
+            823,
+            194
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shao-Hua Sun, Hyeonwoo Noh, Sriram Somasundaram, and Joseph Lim. Neural program synthesis from diverse demonstration videos. In ICML, 2018. ",
+        "bbox": [
+            176,
+            202,
+            823,
+            231
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shubham Tulsiani, Hao Su, Leonidas J. Guibas, Alexei A. Efros, and Jitendra Malik. Learning shape abstractions by assembling volumetric primitives. In CVPR, 2017. ",
+        "bbox": [
+            174,
+            239,
+            823,
+            268
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sjoerd van Steenkiste, Michael Chang, Klaus Greff, and Jurgen Schmidhuber. Relational neural ¨ expectation maximization: Unsupervised discovery of objects and their interactions. In ICLR, 2018. ",
+        "bbox": [
+            176,
+            276,
+            825,
+            320
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yanzhen Wang, Kai Xu, Jun Li, Hao Zhang, Ariel Shamir, Ligang Liu, Zhi-Quan Cheng, and Yueshan Xiong. Symmetry Hierarchy of Man-Made Objects. Computer Graphics Forum, 2011. ",
+        "bbox": [
+            173,
+            328,
+            823,
+            358
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jiajun Wu, Joshua B Tenenbaum, and Pushmeet Kohli. Neural scene de-rendering. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            366,
+            825,
+            382
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhutdinov, Richard S Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In ICML, 2015. ",
+        "bbox": [
+            178,
+            390,
+            823,
+            433
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            458,
+            441,
+            474
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 SCENE CONFIGURATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            491,
+            387,
+            506
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For synthetic data rendering, we use essentially the same settings as in CLEVR (Johnson et al., 2017). The objects are in two sizes (radius 0.4, 0.7), three shapes (sphere, cube, cylinder), two materials (metal, rubber), and eight colors (blue, brown, cyan, gray, green, purple, red, yellow). We represent the colors as numbers 1-8 in the scene programs as shown in Figure 3. ",
+        "bbox": [
+            174,
+            517,
+            826,
+            587
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In the REGULAR setting, objects are placed on a $5 \\times 5 \\times 5$ grid, with integer coordinates in 0-4, which means that the spacial gap between objects is a constant 1. We only use objects with the smaller size. Then we jitter each object position by a random noise sampled uniformly from $[ - 0 . 0 3 , 0 . 0 3 ]$ These random noises are used for visual diversity, and is ignored in the scene program. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            650
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In the RANDOM setting, objects have both large and small sizes, and we use continuous coordinates in [0, 4]. When sampling a program block, the spacial gap between neighboring objects in the same group is still the constant 1, while the entire group is shifted by a continuous random amount. Finally, each object is also independently jittered by a random noise sampled uniformly from $[ - 0 . 0 3 , 0 . 0 3 ]$ . ",
+        "bbox": [
+            174,
+            657,
+            825,
+            713
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 HEURISTIC GROUPING",
+        "text_level": 1,
+        "bbox": [
+            176,
+            729,
+            377,
+            744
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We present the detailed method for heuristic grouping (HG) in Algorithm 2. Here $d ( o , G )$ denotes the minimum Euclidean distance from $o$ to any object in $G$ . During testing we will sample the distance threshold $\\varepsilon$ multiple times. ",
+        "bbox": [
+            174,
+            755,
+            825,
+            797
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.3 DATA FORMAT FOR SCENE PROGRAMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            814,
+            486,
+            829
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In this Section we introduce the data format for the proposed scene programs. In short, a program is represented as a matrix, where each row contains a program command, which is a program token followed by its parameters. In our work, a program block is represented as a matrix of size $N \\times 1 4$ where $N$ is the number of program commands. In order to unify the data format of the programs specified by our DSL defined in Table 1, we divide the 14 numbers into four parts: program token (index 0), iteration arguments (index 1-3), position arguments (index 4-6) and color arguments (index ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2: A simple heuristic grouping algorithm ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            107,
+            519,
+            122
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Result: a group of objects $G$   \nInput: a set of object attributes $O$ , an object $o \\in O$ ;   \n$G = \\{ o \\}$ ;   \nuniformly sample $\\varepsilon$ from $[ 1 , { \\sqrt { 2 } } ]$ ;   \nwhile True do for $o _ { i } \\in O$ do if $o _ { i } \\not \\in G$ and $d ( o _ { i } , G ) < \\varepsilon$ and $o _ { i }$ has the same shape as o then add $o _ { i }$ to $G$ end end if $G$ did not change in this iteration then return $G$ end   \nend ",
+        "bbox": [
+            173,
+            126,
+            645,
+            325
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "7-13). We give an explicit example as shown in Figure 9. The matrix representation allows direct arithmetic operations in program space, which enables the application of scene programs in image analogy making (Figure 8). ",
+        "bbox": [
+            174,
+            356,
+            825,
+            398
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The evaluation of output program is different under different scene configurations. In the REGULAR setting, every program argument is an integer, so we round the output program to the nearest integer and calculate its accuracy. In the RANDOM setting, since the position arguments are continuous, we allow a small error (0.2) for them and treat the other arguments as integers. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            462
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/0c66edbf57386af7621fcd426b2cded2d44c58759c9c196a879a5b3da6f46502.jpg",
+        "image_caption": [
+            "Figure 9: Data format of our scene programs. Each color represents a different type of argument, including red: program tokens, blue: iteration arguments, green: position arguments, purple: color arguments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            476,
+            723,
+            588
+        ],
+        "page_idx": 12
+    }
+]

parse/train/XxP75wV6JGH/XxP75wV6JGH.md

@@ -0,0 +1,477 @@
+# FERMI: Fair Empirical Risk Minimization Via Exponential Rényi Mutual Information
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Despite the success of large-scale empirical risk minimization (ERM) at achieving   
+2 high accuracy across a variety of machine learning tasks, fair ERM is hindered by   
+3 the incompatibility of fairness constraints with stochastic optimization. In this pa  
+4 per, we propose the fair empirical risk minimization via exponential Rényi mutual   
+5 information (FERMI) framework. FERMI is built on a stochastic estimator for ex  
+6 ponential Rényi mutual information (ERMI), an information divergence measuring   
+7 the degree of the dependence of predictions on sensitive attributes. Theoretically,   
+8 we show that ERMI upper bounds existing popular fairness violation metrics, thus   
+9 controlling ERMI provides guarantees on other commonly used violations, such as   
+10 $L _ { \infty }$ . We derive an unbiased estimator for ERMI, which we use to derive the FERMI   
+11 algorithm. We prove that FERMI converges for demographic parity, equalized   
+12 odds, and equal opportunity notions of fairness in stochastic optimization. Em  
+13 pirically, we show that FERMI is amenable to large-scale problems with multiple   
+14 (non-binary) sensitive attributes and non-binary targets. Extensive experiments   
+15 show that FERMI achieves the most favorable tradeoffs between fairness violation   
+16 and test accuracy across all tested setups compared with state-of-the-art baselines   
+17 for demographic parity, equalized odds, equal opportunity. These benefits are   
+18 especially significant for non-binary classification with large sensitive sets and   
+19 small batch sizes, showcasing the effectiveness of the FERMI objective and the   
+20 developed stochastic algorithm for solving it.
+
+# 21 1 Introduction
+
+22 Ensuring that decisions made using machine learning algorithms are fair to different subgroups is   
+23 of utmost importance. Without any mitigation strategy, machine learning algorithms may result in   
+24 discrimination against certain subgroups based on sensitive attributes, such as gender or race, even if   
+25 such discrimination is absent in the training data (Datta et al., 2015; Sweeney, 2013; Bolukbasi et al.,   
+26 2016; Angwin et al., 2016; Calmon et al., 2017b; Feldman et al., 2015; Hardt et al., 2016; Fish et al.,   
+27 2016; Woodworth et al., 2017; Zafar et al., 2017; Bechavod & Ligett, 2017; Kearns et al., 2018)   
+28 Algorithmic fairness literature aims to remedy such discrimination issues.   
+29 A machine learning algorithm satisfies the demographic parity fairness notion, if the predicted target   
+30 is independent of the sensitive attributes (Dwork et al., 2012). Promoting demographic parity can   
+31 lead to poor performance, especially if the true outcome is not independent of the sensitive attributes.   
+32 To remedy this, Hardt et al. $\underline { { \sqrt { 2 0 1 6 } } }$ proposed equalized odds to ensure that the predicted target is   
+33 conditionally independent of the sensitive attributes given the true label. A further relaxed version of   
+34 this notion is equal opportunity which is satisfied if predicted target is conditionally independent of   
+35 sensitive attributes given that the true label is in an advantaged class $\textcircled { 1 } \textcircled { 1 } \textcircled { < } \mathrm { a l . } \textcircled { 2 0 1 6 } )$ . The inherent   
+36 assumption in such conditional notions is that the true labels are fair. These notions suffer from a   
+37 potential amplification of the inherent discrimination that may exist in the training data. Tackling   
+38 such bias is beyond the scope of this work; cf. Kilbertus et al. (2020) and Bechavod et al. $\textcircled { 2 0 1 9 }$
+
+<table><tr><td rowspan=1 colspan=4>Reference</td><td rowspan=1 colspan=1>NBtarget</td><td rowspan=1 colspan=1>NBattrib.</td><td rowspan=1 colspan=1>NBcode</td><td rowspan=1 colspan=3>Fairness notiondp eod eop</td><td rowspan=1 colspan=1>Beyondlogistic</td><td rowspan=1 colspan=1>Stoch. alg.(unbiased**)</td><td rowspan=1 colspan=1>Converg.(stoch.)</td></tr><tr><td rowspan=1 colspan=4>FERMI (this work)</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=2>Cho et al.</td><td rowspan=1 colspan=1>2020b</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>（x）</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=2>Cho et al.</td><td rowspan=1 colspan=1>2020a)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>×</td></tr><tr><td rowspan=1 colspan=3>Baharlouei et al.,|2020]</td><td rowspan=1 colspan=1>2020</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>了</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√（x）</td></tr><tr><td rowspan=1 colspan=3>(Rezaei et al.[2020)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>【</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>(Jiang et al.2020)*</td><td rowspan=1 colspan=1>*</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>(Mary et al..2019)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>【</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√（x）</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>Donini et al.2018]</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=3>Zhang et al..2018)</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>(x)</td><td rowspan=1 colspan=1>X</td></tr></table>
+
+Table 1: Comparison of state-of-the-art in-processing methods. $\mathbf { N B } =$ non-binary, $\mathrm { d } \mathsf { p } =$ demographic parity, eod $=$ equalized odds, $\mathrm { { e o p = } }$ equal opportunity. While satisfying eod guarantees satisfying eop, an eod algorithm does not necessarily achieve a favorable tradeoff between performance and fairness violation in eop; we only credit those works that provide/implement algorithms for a given fairness notion. FERMI is the only method compatible with stochastic optimization and guaranteed convergence. The only existing baselines for non-binary classification with non-binary sensitive attributes are (Mary et al., 2019; Baharlouei et al., 2020; Cho et al., $\textcircled { 2 0 2 0 6 }$ (NB code). ⇤We refer to the in-processing method of $\mathbb { W } \mathrm { i a n g ~ e t ~ a l . } \backslash \mathbb { Z } 0 2 0 \}$ , not their post-processing method. $^ { * * } \mathrm { W e }$ use the term “unbiased” to refer to unbiased estimation in statistical sense; it is not to be confused with bias in the fairness sense, for which we use the term discrimination.
+
+39 Measuring fairness violation. In practice, the learner only has access to finite samples and cannot   
+40 verify demographic parity, equalized odds, or equal opportunity. This has led the machine learning   
+41 community to define several fairness violation metrics that quantify the degree of (conditional)   
+42 independence between random variables, e.g., $L _ { \infty }$ distance (Dwork et al., 2012; Hardt et al., 2016),   
+43 mutual information (Kamishima et al., 2011; Rezaei et al., 2020; Steinberg et al., $\mathbb { Z } 0 2 0 \} ,$ Zhang   
+44 et al., 2018; Cho et al., 2020a), Pearson correlation (Zafar et al., $\overline { { 2 0 1 7 } } )$ , false positive/negative rates   
+45 (Bechavod & Ligett, 2017), Hilbert Schmidt independence criterion (HSIC) (Pérez-Suay et al., 2017),   
+46 Rényi correlation (Mary et al., 2019; Baharlouei et al., 2020; Grari et al., $\boxed { 2 0 1 9 } \boxed { 2 0 2 0 }$ , and exponential   
+47 Rényi mutual information (ERMI) $\boxed { \mathrm { M a r y ~ e t ~ a l . } , \boxed { 2 0 1 9 } }$ . In this paper, we focus on three variants of   
+48 ERMI specialized to demographic parity, equalized odds, and equal opportunity. We prove that ERMI   
+49 provides an upper bound on the rest of the above existing notions of fairness violation. Consequently,   
+50 a model trained to reduce ERMI will also provide guarantees on these other fairness violations.   
+51 We also develop a stochastic estimator for ERMI that is compatible with large-scale stochastic   
+52 optimization, and use it as a regularizer in within ERM, and call it FERMI. We theoretically show   
+53 that FERMI is convergent, and empirically demonstrate that it outperforms all other state-of-the-art   
+54 baselines, including (Mary et al., 2019) which solves the same objective as FERMI.   
+55 Related work & contributions. Fairness-promoting machine learning algorithms can be categorized   
+56 in three main classes: pre-processing, post-processing, and in-processing methods. Pre-processing   
+57 algorithms (Feldman et al., 2015; Zemel et al., 2013; Calmon et al., 2017b) transform the biased   
+58 data features to a new space in which the labels and sensitive attributes are statistically independent.   
+59 This transform is oblivious to the training procedure. Post-processing approaches (Hardt et al., 2016;   
+60 Pleiss et al., 2017) mitigate the discrimination of the classifier by altering the the final decision.   
+61 In-processing approaches focus on the training procedure and impose the notions of fairness as   
+62 constraints or regularization terms in the training procedure. Several regularization-based methods   
+63 are proposed in the literature to promote fairness in decision-trees (Kamiran et al., 2010; Raff et al.,   
+64 2018; Aghaei et al., 2019), support vector machines (Donini et al., 2018), neural networks (Grari   
+65 et al., 2020; Cho et al., 2020b), or (logistic) regression models (Zafar et al., 2017; Berk et al., 2017;   
+66 Taskesen et al., 2020; Chzhen & Schreuder, 2020; Baharlouei et al., 2020; Jiang et al., 2020; Grari   
+67 et al., 2019). While in-processing approaches generally give rise to better tradeoffs between fairness   
+68 violation and performance, existing approaches are mostly incompatible with large-scale stochastic   
+69 optimization. This paper addresses this problem. See below for a summary of our contributions and   
+70 Table 1 for a summary of the main differences between FERMI and existing in-processing methods.
+
+1. We analyze a notion of fairness violation called ERMI. We show that ERMI is a stronger notion of fairness violation than all existing notions. Therefore, a model that ensures small ERMI violation is guaranteed to have small fairness violation with respect to all other notions as well.
+
+74 2. We formulate an empirical objective, called FERMI objective, for using ERMI as a regularizer with empirical risk minimization. We propose a solver for FERMI, which is the first stochastic in-processing fairness algorithm with guaranteed convergence. The existing stochastic fairness algorithms by Zhang et al. (2018); Mary et al. (2019); Cho et al. (2020a,b) are not guaranteed to converge.
+
+3. We demonstrate through extensive numerical experiments that FERMI achieves superior fairness-accuracy tradeoff curves against all comparable baselines, even when fairness violation is measured in terms of commonly used $\overline { { L _ { \infty } } }$ (for demographic parity, equalized odds, and equal opportunity). In particular, the performance gap is very large when minibatch size is small (as is practically necessary for large-scale problems), and the number of sensitive attributes is large.
+
+# 2 Fairness notions: demographic parity, equalized odds, equal opportunity
+
+85 In this section, we state a notion of fairness that generalizes demographic parity, equalized odds,   
+86 and equal opportunity fairness definitions (the three notions considered in this paper). This will be   
+87 convenient for presenting our theoretical results. Consider a learner who trains a model to make   
+88 a prediction, $\widehat { Y }$ , e.g., whether or not to extend a loan, supported on $\mathcal { V }$ which can be discrete or   
+89 continuous. The prediction is made using a set of features, $\mathbf { X }$ , e.g., financial history features. We   
+90 assume that there is a set of discrete sensitive attributes, $S$ , e.g., race and sex, supported on $s$ ,   
+91 associated with each sample. Further, let $\mathcal A \subseteq \mathcal V$ denote an advantaged outcome class, e.g., the   
+92 outcome where a loan is extended.
+
+Definition 1 $( Z , { \mathcal { Z } } )$ -fairness). Given a random variable $Z$ , let $\mathcal { Z }$ be a subset of values that $Z$ can take. We say that a learning machine satisfies $( Z , { \mathcal { Z } } )$ -fairness if for every $z \in { \mathcal { Z } }$ , $\widehat { Y }$ is conditionally independent of $S$ given $Z = z$ , i.e. $\forall \widehat { y } \in \mathcal { V } , s \in \mathcal { S } , z \in \mathcal { Z }$ , $p _ { \widehat { Y } , S | Z } ( \widehat { y } , s | z ) = p _ { \widehat { Y } | Z } ( \widehat { y } | z ) p _ { S | Z } ( s | z )$ .
+
+$( Z , { \mathcal { Z } } )$ -fairness includes the popular demographic parity, equalized odds, and equal opportunity notions of fairness as special cases:
+
+1. $( Z , { \mathcal { Z } } )$ -fairness recovers demographic parity $\left( { \overline { { \mathrm { D w o r k } \ \mathrm { e t } \ \mathrm { a l . } } } } \right) \left[ 2 0 1 2 \right)$ if $Z = 0$ and ${ \mathcal { Z } } = \{ 0 \}$ . In this case, conditioning on $Z$ has no effect, and hence $\overline { { ( 0 , \{ 0 \} ) } }$ fairness is equivalent to the independence between $\widehat { Y }$ and $S$ (see Definition $\boxed { 6 }$ Appendix A)
+
+2. $( Z , { \mathcal { Z } } )$ -fairness recovers equalized odds $\textcircled { \mathrm { H a r d t e t a l . } } \textcircled { 2 0 1 6 } )$ if $Z = Y$ and $\mathcal { Z } = \mathcal { V }$ . In this case, $Z \in { \mathcal { Z } }$ is trivially satisfied. Hence, conditioning on $\overline { Z }$ is equivalent to conditioning on $Y .$ , which recovers the equalized odds notion of fairness, i.e., conditional independence of $\widehat { Y }$ and $S$ given $Y$ (see Definition $\bigtriangledown$ Appendix $\underline { { \overline { { \mathbf { A } } } } } )$ .
+
+3. $( Z , { \mathcal { Z } } )$ -fairness recovers equal opportunity (Hardt et al., $\boxed { 2 0 1 6 }$ if $Z = Y$ and $\mathcal { Z } = \mathcal { A }$ . This is also similar to the previous case with $\mathcal { V }$ replaced with $\overline { { A } }$ (see Definition 8, Appendix $\boxed { \mathrm { A } }$ .
+
+07 Note that verifying $( Z , { \mathcal { Z } } )$ -fairness requires having access to the joint distribution of random variables   
+08 $( Z , { \widehat { Y } } , S )$ . This joint distribution is unavailable to the learner in the context of machine learning, and   
+109 hence the learner would resort to empirical estimation of the amount of violation of independence,   
+10 measured through some divergence. See (Williamson & Menon, 2019) for a related discussion.
+
+# 3 Measuring fairness violation using exponential Rényi mutual information
+
+112 Most existing fairness violations can be viewed as a (conditional) $f$ -divergence between the joint   
+113 distribution of sensitive attributes and predicted targets, $p _ { \widehat { Y } , S | Z }$ , and the Kronecker proudct of the   
+114 marginals, $p _ { \widehat { Y } | Z } \otimes p _ { S | Z }$ . In this section, we focus on ERMI and show that several existing fairness   
+115 violations are upper bounded by ERMI. For brevity, we present all definitions and results $( Z , { \mathcal { Z } } )$ .   
+116 Definition 2 (ERMI – exponential Rényi mutual information). We define the exponential Rényi   
+117 mutual information between $\widehat { Y }$ and $S$ given $Z \in { \mathcal { Z } }$ as
+
+$$
+\begin{array} { r } { D _ { R } ( \widehat { Y } ; S | Z \in \mathcal { Z } ) : = \mathbb { E } _ { Z , \widehat { Y } , S } \left\{ \left. \frac { p _ { \widehat { Y } , S | Z } ( \widehat { Y } , S | Z ) } { p _ { \widehat { Y } | Z } ( \widehat { Y } | Z ) p _ { S | Z } ( S | Z ) } \right| Z \in \mathcal { Z } \right\} - 1 . } \end{array}
+$$
+
+118 In Appendix $\bigtriangledown$ we unravel the definition for the special cases of interest corresponding to demo  
+119 graphic parity, equalied odds, and equal opportunity. We also discuss that ERMI is the $\chi ^ { 2 }$ -divergence   
+120 (which is an $f$ -divergence) between the joint distribution, $p _ { \widehat { Y } , S | Z }$ , and the Kronecker product of   
+121 marginals, $p _ { \widehat { Y } | Z } \otimes p _ { S | Z } \ \mathrm { ( f C a l m o n \ e t \ a l . ) } \mathrm { [ 2 0 1 7 a ] }$ . In particular, ERMI is non-negative, and zero if   
+122 and only if $( Z , { \mathcal { Z } } )$ -fairness is satisfied. In the context of algorithmic fairness, ERMI was first used   
+123 by $\boxed { \mathrm { M a r y ~ e t ~ a l . } } \textcircled { 2 0 1 9 }$ as a regularizer. We will provide a new stochastic solver/estimator for ERMI,   
+124 which theoretically converges and empirically outperforms the one by Mary et al. $\textcircled { 2 0 1 9 }$ .   
+125 Definition 3 (Rényi mutual information (Rényi, 1961)). Let the Rényi mutual information of order   
+126 $\alpha > 1$ between random variables $\widehat { Y }$ and $S$ given $Z \in { \mathcal { Z } }$ be defined as:
+
+$$
+I _ { \alpha } ( \widehat { Y } ; S | Z \in \mathcal { Z } ) : = \frac { 1 } { \alpha - 1 } \log \left( \mathbb { E } _ { z , \widehat { Y } , S } \left\{ \left. \left( \frac { p _ { \widehat { Y } , S | Z } ( \widehat { Y } , S | Z ) } { p _ { \widehat { Y } | Z } ( \widehat { Y } | Z ) p _ { S | Z } ( S | Z ) } \right) ^ { \alpha - 1 } \right| Z \in \mathcal { Z } \right\} \right) ,
+$$
+
+127 which generalizes Shannon mutual information
+
+$$
+I _ { 1 } ( \widehat { Y } ; S | Z \in \mathcal { Z } ) : = \mathbb { E } _ { Z , \widehat { Y } , S } \left\{ \log \left( \frac { p _ { \widehat { Y } , S | Z } ( \widehat { Y } , S | Z ) } { p _ { \widehat { Y } | Z } ( \widehat { Y } | Z ) p _ { S | Z } ( S | Z ) } \right) \Bigg | Z \in \mathcal { Z } \right\} ,
+$$
+
+128 and recovers it as $\begin{array} { r } { \operatorname* { l i m } _ { \alpha  1 ^ { + } } I _ { \alpha } ( \widehat { Y } ; S | Z \in \mathcal { Z } ) = I _ { 1 } ( \widehat { Y } ; S | Z \in \mathcal { Z } ) . } \end{array}$ .
+
+29 Note that $I _ { \alpha } ( \widehat { Y } ; S | Z \in \mathcal { Z } ) \geq 0$ with equality if and only if $( Z , { \mathcal { Z } } )$ -fairness is satisfied.
+
+130 Theorem 1 (ERMI is stronger than Shannon mutual information). We have
+
+$$
+0 \le I _ { 1 } ( \widehat { Y } ; S | Z \in \mathcal { Z } ) \le I _ { 2 } ( \widehat { Y } ; S | Z \in \mathcal { Z } ) \le e ^ { I _ { 2 } ( \widehat { Y } ; S | Z \in \mathcal { Z } ) } - 1 = D _ { R } ( \widehat { Y } ; S | Z \in \mathcal { Z } ) .
+$$
+
+132 All proofs are relegated to the appendix. Theorem $\bigstar$ establishes that ERMI is a stronger measure of   
+133 fairness violation in the sense that driving it to zero would also bound the Shannon mutual information,   
+134 which is used for promoting fairness in recent literature $\mathbb { ( C h o e t a l . , } \mathbb { Z 0 2 0 a ) }$ . It also shows that ERMI   
+135 is exponentially related to the Rényi mutual information of order 2.   
+136 Definition 4 (Rényi correlation (Hirschfeld, 1935; Gebelein, 1941; Rényi, 1959)). Let $\mathcal { F }$ and $\mathcal { G }$   
+137 be the set of measurable functions such that for random variables $\widehat { Y }$ and $S$ , $\overline { { { \mathbb { E } } } } _ { \widehat { Y } } \{ f ( \widehat { Y } ; z ) \} \ =$   
+138 $\mathbb { E } _ { S } \left\{ g ( S ; z ) \right\} = 0 ,$ , $\mathbb { E } _ { \widehat { Y } } \{ f ( \widehat { Y } ; z ) ^ { 2 } \} = \mathbb { E } _ { S } \left\{ g ( S ; z ) ^ { 2 } \right\} = 1$ , for all $z \in { \mathcal { Z } }$ . Rényi correlation is:
+
+$$
+\begin{array} { r } { \rho _ { R } ( \widehat { Y } , S | Z \in \mathcal { Z } ) : = \underset { f , g \in \mathcal { F } \times \mathcal { G } } { \operatorname* { s u p } } \ \mathbb { E } _ { Z , \widehat { Y } , S } \left\{ \left. f ( \widehat { Y } ; Z ) g ( S ; Z ) \right| Z \in \mathcal { Z } \right\} . } \end{array}
+$$
+
+139
+
+140 Rényi correlation generalizes Pearson correlation,
+
+$$
+\rho ( \widehat { Y } , S | Z \in \mathcal { Z } ) : = \mathbb { E } _ { Z } \left\{ \left. \frac { \mathbb { E } _ { \widehat { Y } , S } \{ \widehat { Y } S | Z \} } { \sqrt { \mathbb { E } _ { \widehat { Y } } \{ \widehat { Y } ^ { 2 } | Z \} \mathbb { E } _ { S } \{ S ^ { 2 } | Z \} } } \right| Z \in \mathcal { Z } \right\} ,
+$$
+
+141
+
+142 to capture nonlinear dependencies between the random variables by finding functions of random   
+143 variables that maximize the Pearson correlation coefficient between the random variables. In fact,   
+144 it is true that $\rho _ { R } ( \widehat { Y } , S | Z \in \mathcal { Z } ) \geq 0$ with equality if and only if $( Z , { \mathcal { Z } } )$ -fairness is satisfied. Rényi   
+145 correlation has gained popularity as a measure of fairness violation (Mary et al., 2019; Baharlouei   
+146 et al., $\boxed { 2 0 2 0 }$ Grari et al., 2020). Rényi correlation is also upper bounded by ERMI. The following   
+147 result has already been shown by Mary et al. $\textcircled { | 2 0 1 9 }$ and we present it for completeness.
+
+148 Theorem 2 (ERMI is stronger than Rényi correlation). We have
+
+$$
+0 \le | \rho ( \widehat { Y } , S | Z \in \mathcal { Z } ) | \le \rho _ { R } ( \widehat { Y } , S | Z \in \mathcal { Z } ) \le D _ { R } ( \widehat { Y } ; S | Z \in \mathcal { Z } ) ,
+$$
+
+149 and if $| S | = 2$ , $D _ { R } ( \widehat { Y } ; S | Z \in \mathcal { Z } ) = \rho _ { R } ( \widehat { Y } , S | Z \in \mathcal { Z } ) .$
+
+150 Definition 5 ( $L _ { q }$ fairness violation). We define the $L _ { q }$ fairness violation for $q \geq 1$ by:
+
+$$
+L _ { q } ( \widehat { Y } , S | Z \in \mathcal { Z } ) : = \mathbb { E } \mathcal { Z } \Bigg \{ \Bigg ( \int _ { \widehat { y } \in \mathcal { Y } _ { 0 } } \sum _ { s \in \mathcal { S } _ { 0 } } \left| p _ { \widehat { Y } , S | Z } ( \widehat { y } , s | Z ) - p _ { \widehat { Y } | Z } ( \widehat { y } | Z ) p _ { S | Z } ( s | Z ) \right| ^ { q } d y \Bigg ) ^ { \frac { 1 } { q } } \Bigg | Z \in \mathcal { Z } \Bigg \} .
+$$
+
+151 Note that $L _ { q } ( \widehat { Y } , S | Z \in \mathcal { Z } ) = 0$ if and only if $( Z , { \mathcal { Z } } )$ -fairness is satisfied. In particular, $L _ { \infty }$ fairness   
+152 violation recovers demographic parity violation $( \overline { { \mathrm { K e a r n s ~ e t ~ a l . } } } , \overline { { 2 0 1 8 } } ,$ Definition 2.1) if we let $\mathcal { Z } = \{ 0 \}$   
+153 and $Z = 0$ . It also recovers equal opportunity violation (Hardt et al., 2016) if ${ \mathcal { Z } } = A$ and $Z = Y$ .   
+154 Theorem 3 (ERMI is stronger than $L _ { \infty }$ fairness violation). Let $\widehat { Y }$ be a discrete or continuous random   
+155 variable, and $S$ be a discrete random variable supported on a finite set. Then for any $q \geq 1$ ,
+
+$$
+0 \leq L _ { q } ( \widehat { Y } , S | Z \in \mathcal { Z } ) \leq \sqrt { D _ { R } ( \widehat { Y } , S | Z \in \mathcal { Z } ) } .
+$$
+
+157 The above theorem says that if a method controls ERMI value for imposing fairness, then $L _ { \infty }$   
+158 violation is controlled. In particular, the variant of ERMI that is specialized to demographic parity   
+159 also controls $L _ { \infty }$ demographic parity violation $\mathrm { ( \overline { { K e a r n s \ e t \ a l . } } , \overline { { 2 0 1 8 } } ) }$ . The variant of ERMI that is   
+160 specialized to equal opportunity also controls the $\overline { { L _ { \infty } } }$ equal opportunity violation $\mathbb { ( H a r d t e t a l . } ) \mathbb { 2 0 1 6 ) }$ .   
+161 While our algorithm uses ERMI as a regularizer, in our experiments, we measure fairness violation   
+162 through the more commonly used $L _ { \infty }$ violation. Despite this, we show that our approach leads to   
+163 better tradeoff curves between fairness violation and performance.   
+164 Remark. The bounds in Theorems 1-3 are not tight in general, but this is not of practical concern.   
+165 They show that bounding ERMI is sufficient because any model that achieves small ERMI is   
+166 guaranteed to satisfy any other fairness violation. This makes ERMI an effective regularizer for   
+167 promoting fairness. In fact, in Sec. $\bigtriangledown$ we see that the proposed algorithm, FERMI, achieves the best   
+168 tradeoffs between fairness violation and performance across state-of-the-art baselines.
+
+# 69 4 FERMI: fair empirical risk minimization through ERMI regularization
+
+170 Our goal is to train a model that balances fairness and accuracy objectives. To this end, we introduce fair risk minimization through exponential Rényi mutual information framework defined below:1 171
+
+$$
+\operatorname* { m i n } _ { \pmb { \theta } } \left\{ \mathrm { F R M I } ( \pmb { \theta } ) : = \mathbb { E } _ { \mathbf { X } , Y , S } \left\{ \ell \big ( \mathbf { X } , Y ; \pmb { \theta } \big ) \right\} + \lambda D _ { R } \big ( \widehat { Y } ( \mathbf { X } ; \pmb { \theta } ) ; S \big ) \right\} ,
+$$
+
+(FRMI obj.)
+
+172 where $\ell$ denotes the loss function, such as $L _ { 2 }$ loss or cross entropy loss; $\lambda > 0$ is a scalar balancing   
+173 the accuracy versus fairness objectives; ${ D _ { R } \big ( \widehat { Y } ( { \mathbf { X } } ; { \pmb \theta } ) ; { S } \big ) }$ is the notion of ERMI given in Eq. (ERMI)   
+174 particularized to demographic parity (see Eq. (5)); and $\widehat { Y } ( \mathbf { X } ; \pmb { \theta } )$ is the output of the learned model   
+175 (e.g., the output of a classification or a regression task, or the cluster number in a clustering task).   
+176 While $\widehat { Y } ( \mathbf { X } ; \pmb { \theta } )$ inherently depends on $\mathbf { X }$ and $\pmb { \theta }$ , in the rest of this paper, we sometimes leave the   
+177 dependence of $\widehat { Y }$ on $\mathbf { X }$ and/or $\pmb \theta$ implicit for brevity of notation. Notice that we have also left the   
+178 dependence of the loss on the predicted outcome $\widehat { Y }$ implicit.   
+179 In practice, the true joint distribution of $( \mathbf { X } , S , Y , { \widehat { Y } } )$ is unknown and we only have $N$ samples at   
+180 our disposal, making it impossible to solve FRMI. Let $\{ \mathbf { x } _ { i } , s _ { i } , y _ { i } , \widehat { y } _ { i } ( \mathbf { x } _ { i } ; \pmb { \theta } ) \} _ { i \in [ N ] }$ denote the features,   
+181 sensitive attributes, targets, and the predictions of the model parameterized by $\mathbf { \bar { \theta } }$ for these samples.   
+182 $\boxed { \mathrm { M a r y ~ e t ~ a l . } } ( \boxed { 2 0 1 9 } )$ considered the same objective Eq. $( \mathrm { F R M I \hat { o } b j . } )$ , and tried to empirically solve it   
+183 through a kernel approximation. We propose a completely different approach to solving this problem:   
+184 fair empirical risk minimization via exponential Rényi mutual information (FERMI). FERMI results   
+185 in a provably convergent algorithm, and empirically outperforms the algorithm by $\boxed { \mathrm { M a r y ~ e t ~ a l . } } \textcircled { 2 0 1 9 }$   
+186 It is straightforward to derive an unbiased estimate for $\mathbf { \bar { E } } _ { \mathbf { X } , Y , S } \left\{ \ell ( \mathbf { X } , \mathbf { \bar { Y } } ; \pmb { \theta } ) \right\}$ through the empirical   
+187 risk, e.g., $\begin{array} { r } { \frac { 1 } { | B | } \sum _ { i \in B } \ell \big ( \mathbf { x } _ { i } , y _ { i } ; \pmb { \theta } \big ) } \end{array}$ where $B \subseteq [ N ]$ is a random minibatch of data points. However,   
+188 estimating $D _ { R } ( \widehat { Y } , S )$ in the objective function in Eq. $( \mathrm { F R M I ~ o b j . } )$ is more difficult. In what follows,   
+189 we present our approach to deriving an unbiased stochastic estimator of $D _ { R } ( \widehat { Y } , S )$ given a random   
+190 batch of data points $B$ . The following theorem is the key tool we use to obtain an unbiased estimator:
+
+191 Theorem 4. For discrete random variables $\widehat { Y } = \widehat { Y } ( \mathbf { X } ; \pmb { \theta } )$ and $S$ where $\widehat { Y } \in [ m ] , S \in [ k ]$ , we have
+
+$$
+D _ { R } ( \widehat { Y } ; S ) = \operatorname* { m a x } _ { W \in \mathbb { R } ^ { k \times m } } \Big \{ - \operatorname { T r } ( W P _ { \widehat { y } } W ^ { T } ) + 2 \operatorname { T r } ( W P _ { \widehat { y } , s } P _ { s } ^ { - 1 / 2 } ) - 1 \Big \} ,
+$$
+
+192 where $P _ { \widehat { \cal Y } } = \mathrm { d i a g } ( p _ { \widehat { \cal Y } } ( 1 ) , \ldots , p _ { \widehat { \cal Y } } ( m ) )$ , $P _ { s } = \mathrm { d i a g } ( p _ { S } ( 1 ) , \dots , p _ { S } ( k ) )$ , and
+
+$$
+P _ { \widehat { y } , s } = \left( \begin{array} { c c c } { p _ { \widehat { Y } , S } ( 1 , 1 ) } & { \ldots } & { p _ { \widehat { Y } , S } ( 1 , k ) } \\ { \vdots } & { \ddots } & { \vdots } \\ { p _ { \widehat { Y } , S } ( m , 1 ) } & { \ldots } & { p _ { \widehat { Y } , S } ( m , k ) } \end{array} \right) .
+$$
+
+Let 193 $\widehat { \mathbf Y }$ , $\widehat { \mathbf { y } } _ { i } \in \{ 0 , 1 \} ^ { m }$ and S, $\mathbf { s } _ { i } \in \{ 0 , 1 \} ^ { k }$ be the one-hot encodings of $\widehat { Y } , \widehat { y } _ { i }$ and $S , s _ { i }$ , respectively. b b194 Then, the above theorem implies that we can compute an unbiased estimate of Eq. (FRMI obj.):
+
+195 Lemma 1 (Unbiased estimator of ERMI). Let $( \mathbf { X } , S , Y , \widehat { Y } ( \mathbf { X } ; \pmb { \theta } ) )$ be a random draw from $P _ { { \bf X } , S , Y , \widehat { Y } }$   
+196 Further, let
+
+$$
+\begin{array} { r } { \psi ( { \mathbf { X } } , S , Y , \widehat { Y } ; \pmb { \theta } , W ) : = - \operatorname { T r } ( W \widehat { \mathbf { Y } } ( { \mathbf { X } } ; \pmb { \theta } ) \widehat { \mathbf { Y } } ^ { T } ( { \mathbf { X } } ; \pmb { \theta } ) W ^ { T } ) + 2 \operatorname { T r } ( W \widehat { \mathbf { Y } } ( { \mathbf { X } } ; \pmb { \theta } ) { \mathbf { S } } ^ { T } P _ { s } ^ { - 1 / 2 } ) - 1 . } \end{array}
+$$
+
+197198 Then, $\operatorname* { m a x } _ { W \in \mathbb { R } ^ { k \times m } } \psi ( \mathbf { X } , S , Y , \widehat { Y } ; \pmb { \theta } , W )$ is an unbiased estimator of ERMI in Eq. (FRMI obj.), i.e.,
+
+$$
+\mathbb { E } _ { { \mathbf { X } } , S , Y } \Big \{ \operatorname* { m a x } _ { W \in \mathbb { R } ^ { k \times m } } \psi ( { \mathbf { X } } , S , Y , \widehat { Y } ; \pmb { \theta } , W ) \Big \} = D _ { R } ( \widehat { Y } ( { \mathbf { X } } ; \pmb { \theta } ) ; S ) .
+$$
+
+199200 The stochastic estimator, $\psi ( { \mathbf { X } } , S , Y , \widehat { Y } ; \pmb { \theta } , W )$ , in Lemma $\boxed { 1 }$ requires the knowledge of $P _ { s }$ , and   
+201 computation of $P _ { s } ^ { - 1 / 2 }$ . This can be estimated with high fidelity (for small to moderate sensitive set)   
+202 through a single initial pass over the entire dataset in practice. Hence, we consider it to be known.   
+203 Now, we are equipped to state the empirical objective function that we solve in this paper:
+
+$$
+\operatorname* { m i n } _ { \theta } \operatorname* { m a x } _ { W \in \mathbb { R } ^ { k \times m } } \left\{ \mathrm { F E R M I } ( \theta , W ) : = \frac { 1 } { N } \sum _ { i \in [ N ] } \left[ \ell ( \mathbf { x } _ { i } , y _ { i } ; \theta ) + \lambda \psi _ { i } ( \pmb { \theta } , W ) \right] \right\} ,
+$$
+
+204 where
+
+$$
+\psi _ { i } ( \pmb \theta , W ) : = - \operatorname { T r } ( W \widehat { \mathbf y } _ { i } ( \mathbf x _ { i } ; \pmb \theta ) \widehat { \mathbf y } _ { i } ^ { T } ( \mathbf x _ { i } ; \pmb \theta ) W ^ { T } ) + 2 \operatorname { T r } ( W \widehat { \mathbf y } _ { i } ( \mathbf x _ { i } ; \pmb \theta ) \mathbf s _ { i } ^ { T } P _ { s } ^ { - 1 / 2 } ) - 1 .
+$$
+
+205 In particular, Lemma $^ 1$ says that, for any $N$ , Eq. $\mathrm { ( F E R M I o b j . ) }$ (and its gradients) is an unbiased and   
+206 consistent estimator of the Eq. $( \mathrm { F R M I } \ \mathrm { o b j . } )$ objective function (and its gradients) by an empirical   
+207 average over the minibatch. This is in contrast to the density estimation methods used by Mary et al.   
+208 $\bar { ( 2 0 1 9 ) }$ and Baharlouei et al. $\underline { { \textregistered 2 0 2 0 } }$ , which are biased but consistent. We will see in the experiments   
+209 that the unbiased estimator empirically offers large performance improvements.
+
+210 This observations leads us to deriving a stochastic algorithm, presented in Algorithm $\mathbb { L } ,$ which is guaranteed to converge for any batch size $1 \le | B | \le \bar { N }$ since the stochastic gradients are unbiased.
+
+# Algorithm 1 (FERMI Algorithm). Two-Time Scale SGDA for solving FERMI objective
+
+1: Input: $\pmb { \theta } ^ { 0 } \in \mathbb { R } ^ { d _ { \theta } }$ , $W ^ { 0 } \in \mathcal { W } \subset \mathbb { R } ^ { k \times m }$ , step-sizes $( \eta _ { \theta } , \eta _ { w } )$ , mini-batch $B \subseteq [ N ]$ , fairness   
+parameter $\lambda \geq 0$ , iteration number $R$ .   
+2: for $t = 0 , 1 , \ldots , R$ do   
+3: 4: Set Draw a mini-batch $\begin{array} { r l } & { \mathrm { ~ \it ~ N ~ a ~ m m u n - b a t c h ~ \it ~ B ~ o ~ f ~ d a t a ~ p o m t s ~ \{ ~ ( x _ { i } , ~ { s _ { i } } , ~ { y _ { i } } ) \} _ { i \in \it B } } } \\ & { \mathrm { ~ \it ~ \beta ^ { t + 1 } ~  ~ } \theta ^ { t } - \frac { \eta _ { \theta } } { | \it B | } \sum _ { i \in \it B } [ \nabla _ { \theta } \ell ( { \bf x } _ { i } , y _ { i } ; \theta ^ { t } ) + \lambda \nabla _ { \theta } \psi _ { i } ( \theta ^ { t } , W ^ { t } ) ] . } \\ & { \mathrm { ~ \it ~ W ^ { t + 1 } ~  ~ } \Pi _ { \mathcal { W } } \Big ( W ^ { t } + \frac { 2 \lambda \eta _ { w } } { | \it B | } \sum _ { i \in \it B } \Big [ - W \hat { \bf y } _ { i } ( { \bf x } _ { i } ; \theta ^ { t } ) \hat { \bf y } _ { i } ^ { T } ( { \bf x } _ { i } ; \theta ^ { t } ) + P _ { s } ^ { - 1 / 2 } { \bf s } _ { i } \hat { \bf y } _ { i } ^ { T } ( { \bf x } _ { i } ; \theta ^ { t } ) \Big ] \Big ) } \end{array}$ of data points   
+5: Se   
+6: end for   
+7: Pick $\hat { t }$ uniformly at random from $\{ 1 , \ldots , R \}$ .   
+8: Return: $\theta ^ { \hat { t } }$ .
+
+212 Theorem 5. (Informal statement) Algorithm 1 converges to the set of ✏-first order stationary points of the Eq. (FERMI obj.) objective in 213 $\textstyle { \check { O } } ( { \frac { 1 } { \epsilon ^ { 4 } } } )$ iterations (stochastic gradient evaluations).
+
+The formal statement of this theorem can be found in Theorem $\boxed { 1 0 }$ in Appendix D. A faster convergence rate of $O ( \textstyle { \frac { 1 } { \epsilon ^ { 3 } } } )$ could be obtained by using the (more complicated) SREDA method of Luo et al. (2020) instead of SGDA to solve FERMI objective. We omit the details here. In the next section, we numerically evaluate the performance FERMI algorithm in several numerical experiments.
+
+# 5 Numerical experiments
+
+# 5.1 Binary classification and binary sensitive attribute
+
+For our first set of experiments, we evaluate the fairness-accuracy tradeoffs of FERMI in binary classification problems with a binary sensitive attribute. This is a common setup, so we are able to compare against many existing baseline methods (Zafar et al., 2017; Feldman et al., 2015; Kamishima et al., 2011; Jiang et al., 2020; Hardt et al., 2016; Baharlouei et al., 2020; Rezaei et al., 2020; Donini et al., 2018; Cho et al., 2020b). We run experiments on three data sets: Adult, German Credit, and COMPAS. To implement FERMI, we train a logistic regression model (same model for all baselines) with an ERMI regularizer. Details about the datasets and experiments can be found in Appendix E.
+
+![](images/9f773481d07b948211dc9a8cffebaad609a31409505d8e15bec2e7c529c5424c.jpg)  
+Figure 1: Binary classification with binary sensitive attribute using logistic regression. Tradeoff of fairness violation vs. test error for state-of-the-art fair classifiers on German Credit, Adult, and COMPAS datasets. FERMI offers the best fairness vs. accuracy tradeoff curve in all experiments against all baselines. Rezaei et al. $\left( \left| 2 0 2 0 \right. \right.$ only allow for a single output and do not yield a tradeoff curve. Further, the algorithms by Mary et al. (2019) and Baharlouei et al. $] ( \underline { { 2 0 2 0 } } )$ are equivalent in this binary setting and shown by the red curve. FERMI, Mary et al. $\overline { { ( 2 0 1 9 ) } }$ and Baharlouei et al. $\dot { ( 2 0 2 0 ) }$ try to empirically solve the same risk function Eq. $\underline { { \operatorname { \mathrm { ( F R M I } } } }$ obj.). However, the empirical formulation used by FERMI, Eq. $\mathrm { ( \mathbb { F } E R M I o b j . ) }$ and its solver result in a better performance even-though we are using a full-batch for all baselines in this experiment.
+
+In Fig. 1, we report the fairness violation vs. test error, for three notions of fairness: demographic parity, equalized odds, and equal opportunity. We have only included in-processing methods, which outperform pre-processing and post-processing methods. Complete experimental results are included in the appendix. We measure fairness violation through conditional demographic parity $L _ { \infty }$ violation (Definition 9), conditional equal opportunity $L _ { \infty }$ violation (Definition $\bar { 1 0 ) }$ and its generalization, conditional equalized odds violation. As can be seen, FERMI offers a fairness-accuracy tradeoff curve that dominates all existing state-of-the-art baselines in each experiment and with respect to each notion of fairness. This demonstrates the efficacy of having a strong regularizer such as ERMI: by enforcing small ERMI violation, our model simultaneously achieves small fairness violation with respect to these other notions which are upper bounded by ERMI.
+
+It is noteworthy that the empirical objective function of $\boxed { \mathrm { M a r y ~ e t ~ a l . } } \textcircled { 2 0 1 9 }$ and Baharlouei et al. $\underline { { \textregistered 0 2 0 } } )$ is exactly the same in this setting, and their algorithms also coincide to the red curve in Fig. 1. 2 Additionally, like FERMI, they are trying to empirically solve Eq. (FRMI obj.), albeit using different estimation techniques, i.e., their empirical objective is different from Eq. (FERMI obj.). This demonstrates the effectiveness of our empirical formulation (FERMI obj.) – which is both unbiased and consistent whereas theirs is biased. It also shows the effectiveness of our solver (Algorithm 1) even-though we are using all baselines in full batch mode in this experiment. In the following experiments, we will demonstrate that using smaller batch sizes results in much more pronounced advantages of FERMI over these baselines.
+
+![](images/b3cdbe721450ac272cb641aad83b868a5e75312be9b78dae7e732110db27f388.jpg)  
+Figure 2: Comparison between FERMI, Mary et al. $\textcircled { 2 0 1 9 }$ , Baharlouei et al. $\underline { { \textregistered 0 2 0 } }$ , and Cho et al. $\textcircled { 2 0 2 0 6 }$ o n Communities dataset. (Mary et al., 2019) outperforms (Baharlouei et al., 2020; Cho et al., 2020b) which we believe could be attributed to the effectiveness of ERMI as a regularizer. FERMI outperforms Mary et al. $\textcircled { 2 0 1 9 }$ , which we attribute to our empirical formulation of ERMI and the effectiveness of its solver, given that we try to empirically solve the same risk function with different formulations.
+
+# 6 5.2 Non-binary fair classification with a non-binary sensitive attribute
+
+Next, we consider a non-binary classification problem with non-binary sensitive set. In this case, we consider the Communities and Crime dataset, which has 18 binary sensitive attributes in total, and we pick a subset of $1 , 2 , 3 , \ldots , 1 8$ sensitive attributes out of those for our experiments, which corresponds to $| S | \in \{ 2 , 4 , 8 , \dots , 2 ^ { 1 8 } \}$ . We discretize the target into three classes $\{ \mathrm { h i g h }$ , medium, $\left. { l o w } \right\}$ . The only baselines that we are aware of that can handle non-binary classification with non-binary sensitive attributes are (Mary et al., 2019), (Baharlouei et al., 2020), (Cho et al., 2020b), (Cho et al., 2020a), and (Zhang et al., 2018). We used the publicly available implementations of (Baharlouei et al., 2020) and (Cho et al., 2020b) and extended their binary classification algorithms to the non-binary setting.
+
+The results are presented in Fig. $^ { 2 , }$ where we use conditional demographic parity $L _ { \infty }$ violation (Definition 9) and conditional equal opportunity $L _ { \infty }$ violation (Definition $\bar { 1 0 } )$ as the fairness violation notions for the two experiments. For all baselines, test error increases as the number of sensitive attributes increases. As can be seen, compared to the baselines, FERMI offers the most favorable test error vs. fairness violation tradeoffs, particularly as the number of sensitive attributes increases and for the more stringent fairness violation levels, e.g., 0.02.
+
+# 5.3 Domain generalization through FERMI
+
+In our last experiment, our goal is to showcase the efficacy of FERMI in stochastic optimization with neural network approximation. For this experiment, we consider the Color MNIST dataset $\operatorname { \mathbb { E } i } \ \&$ Vasconcelos, 2019), where all 60,000 training MNIST digits are colored with different colors drawn from a class conditional Gaussian distribution with variance $\sigma$ around a certain average color for each digit, while the test set remains black and white. $\operatorname { L i } \ \& \ \operatorname { V a s c o n c e l o s } \left( \beta 0 1 9 \right)$ show that as $\sigma  0$ , a convolutional network model overfits significantly to each digit’s color on the training set, and achieves vanishing training accuracy. However, the learned representation does not generalize to the regular black and white test set, in absence of the spurious correlation between digits and color.
+
+270 Conceptually, the goal of the classifier in this problem is to achieve high classification accuracy with   
+271 predictions that are independent of the color of the digit. We view color as the sensitive attribute   
+272 in this experiment, and apply fairness baselines for the demographic parity notion of fairness. One   
+273 would expect that by promoting such independence through a fairness regularizer generalization   
+274 would improve (i.e. lower test error on the black and white test set), at the cost of increased training   
+275 error (on the colored training set). We compare against Mary et al. (2019), Baharlouei et al. $\bar { ( 2 0 2 0 ) }$   
+276 and Cho et al. (2020b) as baselines in this experiment.   
+277 The results of this experiment are as illustrated in Fig. 3. The details about the dataset and experimental   
+278 setup is provided in Appendix $\operatorname { E } .$ In the left panel, we see that with no regularization $\lambda = 0$ ); the   
+279 test error is around $80 \%$ . As $\lambda$ increases, all methods achieve smaller test error while training error   
+280 increases. We also observe that FERMI offers the best test error in this setup. In the right panel,   
+281 we observe that decreasing the batch size results in significantly worse generalization for all three
+
+![](images/cdd91a2e541695afe351b6eafabfb3e030f4a1aafed01b589cdff1812686dcdf.jpg)
+
+![](images/ecc5305eb0bd24a4d5180fc2d808568ba4769409b85473f5b4c102a0c9053c39.jpg)  
+Figure 3: Domain generalization on Color MNIST (Li & Vasconcelos, 2019) using in-process fair algorithms for demographic parity. Left panel: The dashed line is the training error and the solid line is test error. As $\lambda$ increases, fairness regularization results in a learned representation that is less dependent on color; hence training error increases while test error decreases (all algorithms reach a plateau around $\lambda = 8$ ). We use $| B | = 5 1 2$ for all baselines. Right panel: We plot test error vs. batch size using an optimized value of $\lambda$ for each algorithm selected via a validation set. The performance of all baselines drops $10 \%$ as batch size becomes small whereas FERMI is relatively insensitive to batch size.
+
+baselines considered (due to their biased estimators for the regularizer). However, the impact is much less on FERMI. In particular, the performance gap between FERMI and other baselines is more than $20 \%$ for $| B | = 6 4$ . Finally, FERMI with minibatch size $| B | = 6 4$ still outperforms all other baselines with $| B | > 1 , 0 0 0$ . Finally, notice that the test error achieved by FERMI when $\sigma = 0$ is $\sim 3 0 \%$ , as compared to more than $5 0 \%$ obtained using REPAIR (Li & Vasconcelos, 2019) for $\sigma \leq 0 . 0 5$ .
+
+# 6 Discussion & concluding remarks
+
+In this paper, we studied three variants of a notion of fairness violation, called exponential Rényi mutual information (ERMI), developed for demographic parity, equalized odds, and equal opportunity notions of fairness. We showed that ERMI is a strong fairness violation divergence providing upper bound guarantees on other popular violation divergences, namely Shannon mutual information, Rényi mutual information (Theorem $\bigstar \bigstar \bigstar$ , Pearson correlation, Rényi correlation (Theorem $\bigstar$ , and $L _ { q }$ distance violation (Theorem $3 )$ .
+
+We derived an unbiased estimator for ERMI (Lemma 1), based on which we formulated an empirical objective (FERMI obj.) for solving fair empirical risk minimization with ERMI regularization to balance performance and fairness. We provided a stochastic algorithm for solving FERMI (Algorithm $\bar { \bigtriangledown }$ and proved its convergence (Theorem 5); for non-binary sensitive attributes, non-binary target variables, regardless of the batch size. From an experimental perspective, we showed that FERMI leads to better fairness-accuracy tradeoffs than all of the state-of-the-art baselines on a wide variety of binary and non-binary classification tasks (for demographic parity, equalized odds, and equal opportunity). We also showed that these benefits are particularly significant when the number of sensitive attributes grows or the batch size is small. In particular, we observed that FERMI consistently outperforms $\boxed { \mathrm { M a r y ~ e t ~ a l . } } \textcircled { 2 0 1 9 }$ (which tries to empirically solve the same objective Eq. $\left( \mathrm { F R M I o b j . } \right) .$ by up to $20 \%$ when the batch size is small, suggesting that the unbiasedness of the FERMI estimator is essential in achieving good empirical performance.
+
+306 There are several possible explanations for the superior empirical performance of FERMI compared   
+307 to baselines. One possible reason is that the objective function Eq. (FERMI obj.) is easier to optimize   
+308 than the objectives of competing in-processing methods: ERMI is smooth; and in the discrete case, is   
+309 equal to the trace of a matrix (see Theorem $\textcircled { 7 }$ appendix), which is easy to compute. Contrast this with   
+310 the larger computational overhead of Rényi correlation used by Baharlouei et al. $\underline { { \textregistered 2 0 2 0 } }$ , for example,   
+311 which requires finding the second singular value of a matrix. Furthermore, the sample complexity of   
+312 estimating Rényi mutual information of order 2 (and consequently that of ERMI) scales as $\Theta ( \sqrt { | { \cal S } | } )$   
+313 as compared to Shannon mutual information which scales as $\Theta ( | S | / \log | S | )$ (Acharya et al., 2014).   
+314 Moreover, the fact that ERMI is a stronger fairness violation seems to imply that FERMI would   
+315 generalize well to other fairness notions, a hypothesis that is supported by our experimental results.   
+316 Together, these facts suggest that ERMI serves as an efficient and easily optimizable proxy for these   
+317 other fairness notions, making Eq. (FERMI obj.) a good surrogate objective to optimize for all three   
+318 notions of fairness considered (demographic parity, equalized odds, and equal opportunity). We leave   
+319 it as future work to rigorously understand which of these (or other) factors are most responsible for   
+320 the favorable performance tradeoffs observed from FERMI.
+
+References   
+Acharya, J., Orlitsky, A., Suresh, A. T., and Tyagi, H. The complexity of estimating Rényi entropy. arXiv:1408.1000v1, 2014.   
+Aghaei, S., Azizi, M. J., and Vayanos, P. Learning optimal and fair decision trees for nondiscriminative decision-making. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 1418–1426, 2019.   
+Angwin, J., Larson, J., Mattu, S., and Kirchner, L. Machine bias. ProPublica, 2016.   
+Baharlouei, S., Nouiehed, M., Beirami, A., and Razaviyayn, M. Rényi fair inference. In ICLR, 2020.   
+Bechavod, Y. and Ligett, K. Penalizing unfairness in binary classification. arXiv preprint arXiv:1707.00044, 2017.   
+Bechavod, Y., Ligett, K., Roth, A., Waggoner, B., and Wu, Z. S. Equal opportunity in online classification with partial feedback. arXiv preprint arXiv:1902.02242, 2019.   
+Berk, R., Heidari, H., Jabbari, S., Joseph, M., Kearns, M., Morgenstern, J., Neel, S., and Roth, A. A convex framework for fair regression. arXiv preprint arXiv:1706.02409, 2017.   
+Bolukbasi, T., Chang, K.-W., Zou, J. Y., Saligrama, V., and Kalai, A. T. Man is to computer programmer as woman is to homemaker? debiasing word embeddings. In Advances in neural information processing systems, pp. 4349–4357, 2016.   
+Calmon, F., Makhdoumi, A., Médard, M., Varia, M., Christiansen, M., and Duffy, K. R. Principal inertia components and applications. IEEE Transactions on Information Theory, 63(8):5011–5038, 2017a.   
+Calmon, F., Wei, D., Vinzamuri, B., Ramamurthy, K. N., and Varshney, K. R. Optimized preprocessing for discrimination prevention. In Advances in Neural Information Processing Systems, pp. 3992–4001, 2017b.   
+Cho, J., Hwang, G., and Suh, C. A fair classifier using mutual information. In 2020 IEEE International Symposium on Information Theory (ISIT), pp. 2521–2526. IEEE, 2020a.   
+Cho, J., Hwang, G., and Suh, C. A fair classifier using kernel density estimation. In Larochelle, H., Ranzato, M., Hadsell, R., Balcan, M., and Lin, H. (eds.), Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020b.   
+Chzhen, E. and Schreuder, N. A minimax framework for quantifying risk-fairness trade-off in regression. arXiv preprint arXiv:2007.14265, 2020.   
+Cover, T. M. and Thomas, J. A. Information theory and statistics. Elements of Information Theory, 1 (1):279–335, 1991.   
+Csiszár, I. and Shields, P. C. Information theory and statistics: A tutorial. Now Publishers Inc, 2004.   
+Datta, A., Tschantz, M. C., and Datta, A. Automated experiments on ad privacy settings. Proceedings on privacy enhancing technologies, 2015(1):92–112, 2015.   
+Dembo, A. and Zeitouni, O. Large deviations techniques and applications. Springer Science & Business Media, 2009.   
+Donini, M., Oneto, L., Ben-David, S., Shawe-Taylor, J. S., and Pontil, M. Empirical risk minimization under fairness constraints. In Advances in Neural Information Processing Systems, pp. 2791–2801, 2018.   
+Dwork, C., Hardt, M., Pitassi, T., Reingold, O., and Zemel, R. Fairness through awareness. In Proceedings of the 3rd innovations in theoretical computer science conference, pp. 214–226, 2012.   
+Feldman, M., Friedler, S. A., Moeller, J., Scheidegger, C., and Venkatasubramanian, S. Certifying and removing disparate impact. In proceedings of the 21th ACM SIGKDD international conference on knowledge discovery and data mining, pp. 259–268, 2015.   
+367 Fish, B., Kun, J., and Lelkes, Á. D. A confidence-based approach for balancing fairness and accuracy. In Proceedings of the 2016 SIAM International Conference on Data Mining, pp. 144–152. SIAM, 2016.   
+370 Gebelein, H. Das statistische problem der korrelation als variations-und eigenwertproblem und sein zusammenhang mit der ausgleichsrechnung. ZAMM-Journal of Applied Mathematics and Mechanics/Zeitschrift für Angewandte Mathematik und Mechanik, 21(6):364–379, 1941. Grari, V., Ruf, B., Lamprier, S., and Detyniecki, M. Fairness-aware neural Réyni minimization for continuous features. arXiv preprint arXiv:1911.04929, 2019. Grari, V., Hajouji, O. E., Lamprier, S., and Detyniecki, M. Learning unbiased representations via Rényi minimization. arXiv preprint arXiv:2009.03183, 2020. Hardt, M., Price, E., and Srebro, N. Equality of opportunity in supervised learning. In Advances in neural information processing systems, pp. 3315–3323, 2016. Hirschfeld, H. O. A connection between correlation and contingency. In Proceedings of the Cambridge Philosophical Society, volume 31, pp. 520–524, 1935. Jiang, R., Pacchiano, A., Stepleton, T., Jiang, H., and Chiappa, S. Wasserstein fair classification. In Uncertainty in Artificial Intelligence, pp. 862–872. PMLR, 2020. Kamiran, F., Calders, T., and Pechenizkiy, M. Discrimination aware decision tree learning. In 2010 IEEE International Conference on Data Mining, pp. 869–874. IEEE, 2010.   
+385 Kamishima, T., Akaho, S., and Sakuma, J. Fairness-aware learning through regularization approach. In 2011 IEEE 11th International Conference on Data Mining Workshops, pp. 643–650. IEEE, 2011.   
+388 Kearns, M., Neel, S., Roth, A., and Wu, Z. S. Preventing fairness gerrymandering: Auditing and learning for subgroup fairness. In International Conference on Machine Learning, pp. 2564–2572, 2018. Kilbertus, N., Rodriguez, M. G., Schölkopf, B., Muandet, K., and Valera, I. Fair decisions despite imperfect predictions. In Chiappa, S. and Calandra, R. (eds.), Proceedings of the Twenty Third International Conference on Artificial Intelligence and Statistics, volume 108 of Proceedings of Machine Learning Research, pp. 277–287. PMLR, 26–28 Aug 2020. Lecun, Y., Bottou, L., Bengio, Y., and Haffner, P. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. doi: 10.1109/5.726791.   
+397 Li, Y. and Vasconcelos, N. Repair: Removing representation bias by dataset resampling. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9572–9581, 2019.   
+400 Lin, T., Jin, C., and Jordan, M. I. On gradient descent ascent for nonconvex-concave minimax problems. arXiv: 1906.00331v6, 2020. Luo, L., Ye, H., and Zhang, T. Stochastic recursive gradient descent ascent for stochastic nonconvexstrongly-concave minimax problems. arXiv: 2001.03724, 2020. Mary, J., Calauzenes, C., and El Karoui, N. Fairness-aware learning for continuous attributes and treatments. In International Conference on Machine Learning, pp. 4382–4391. PMLR, 2019. Pérez-Suay, A., Laparra, V., Mateo-García, G., Muñoz-Marí, J., Gómez-Chova, L., and Camps-Valls, G. Fair kernel learning. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 339–355. Springer, 2017. Pleiss, G., Raghavan, M., Wu, F., Kleinberg, J., and Weinberger, K. Q. On fairness and calibration. In Advances in Neural Information Processing Systems, pp. 5680–5689, 2017.   
+411 Raff, E., Sylvester, J., and Mills, S. Fair forests: Regularized tree induction to minimize model bias. In Proceedings of the 2018 AAAI/ACM Conference on AI, Ethics, and Society, pp. 243–250, 2018.
+
+413 Rényi, A. On measures of dependence. Acta Mathematica Academiae Scientiarum Hungarica, 10   
+414 (3-4):441–451, 1959.   
+415 Rényi, A. On measures of entropy and information. In Proceedings of the Fourth Berkeley Symposium   
+416 on Mathematical Statistics and Probability, Volume 1: Contributions to the Theory of Statistics.   
+417 The Regents of the University of California, 1961.   
+418 Rezaei, A., Fathony, R., Memarrast, O., and Ziebart, B. D. Fairness for robust log loss classification.   
+419 In AAAI, pp. 5511–5518, 2020.   
+420 Steinberg, D., Reid, A., O’Callaghan, S., Lattimore, F., McCalman, L., and Caetano, T. Fast fair   
+421 regression via efficient approximations of mutual information. arXiv preprint arXiv:2002.06200,   
+422 2020.   
+423 Sweeney, L. Discrimination in online ad delivery. arXiv preprint arXiv:1301.6822, 2013.   
+424 Taskesen, B., Nguyen, V. A., Kuhn, D., and Blanchet, J. A distributionally robust approach to fair   
+425 classification. arXiv preprint arXiv:2007.09530, 2020.   
+426 Williamson, R. and Menon, A. Fairness risk measures. In International Conference on Machine   
+427 Learning, pp. 6786–6797. PMLR, 2019.   
+428 Witsenhausen, H. S. On sequences of pairs of dependent random variables. SIAM Journal on Applied   
+429 Mathematics, 28(1):100–113, 1975.   
+430 Woodworth, B., Gunasekar, S., Ohannessian, M. I., and Srebro, N. Learning non-discriminatory   
+431 predictors. arXiv preprint arXiv:1702.06081, 2017.   
+432 Zafar, M. B., Valera, I., Rogriguez, M. G., and Gummadi, K. P. Fairness constraints: Mechanisms for   
+433 fair classification. In Artificial Intelligence and Statistics, pp. 962–970. PMLR, 2017.   
+434 Zemel, R., Wu, Y., Swersky, K., Pitassi, T., and Dwork, C. Learning fair representations. In   
+435 International Conference on Machine Learning, pp. 325–333, 2013.   
+436 Zhang, B. H., Lemoine, B., and Mitchell, M. Mitigating unwanted biases with adversarial learning.   
+437 In Proceedings of the 2018 AAAI/ACM Conference on AI, Ethics, and Society, pp. 335–340, 2018.
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes]   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [No]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes]   
+(b) Did you mention the license of the assets? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/XxP75wV6JGH/XxP75wV6JGH_content_list.json

@@ -0,0 +1,1306 @@
+[
+    {
+        "type": "text",
+        "text": "FERMI: Fair Empirical Risk Minimization Via Exponential Rényi Mutual Information ",
+        "text_level": 1,
+        "bbox": [
+            214,
+            122,
+            784,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            578,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Despite the success of large-scale empirical risk minimization (ERM) at achieving   \n2 high accuracy across a variety of machine learning tasks, fair ERM is hindered by   \n3 the incompatibility of fairness constraints with stochastic optimization. In this pa  \n4 per, we propose the fair empirical risk minimization via exponential Rényi mutual   \n5 information (FERMI) framework. FERMI is built on a stochastic estimator for ex  \n6 ponential Rényi mutual information (ERMI), an information divergence measuring   \n7 the degree of the dependence of predictions on sensitive attributes. Theoretically,   \n8 we show that ERMI upper bounds existing popular fairness violation metrics, thus   \n9 controlling ERMI provides guarantees on other commonly used violations, such as   \n10 $L _ { \\infty }$ . We derive an unbiased estimator for ERMI, which we use to derive the FERMI   \n11 algorithm. We prove that FERMI converges for demographic parity, equalized   \n12 odds, and equal opportunity notions of fairness in stochastic optimization. Em  \n13 pirically, we show that FERMI is amenable to large-scale problems with multiple   \n14 (non-binary) sensitive attributes and non-binary targets. Extensive experiments   \n15 show that FERMI achieves the most favorable tradeoffs between fairness violation   \n16 and test accuracy across all tested setups compared with state-of-the-art baselines   \n17 for demographic parity, equalized odds, equal opportunity. These benefits are   \n18 especially significant for non-binary classification with large sensitive sets and   \n19 small batch sizes, showcasing the effectiveness of the FERMI objective and the   \n20 developed stochastic algorithm for solving it. ",
+        "bbox": [
+            148,
+            347,
+            766,
+            625
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "21 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            637,
+            312,
+            655
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "22 Ensuring that decisions made using machine learning algorithms are fair to different subgroups is   \n23 of utmost importance. Without any mitigation strategy, machine learning algorithms may result in   \n24 discrimination against certain subgroups based on sensitive attributes, such as gender or race, even if   \n25 such discrimination is absent in the training data (Datta et al., 2015; Sweeney, 2013; Bolukbasi et al.,   \n26 2016; Angwin et al., 2016; Calmon et al., 2017b; Feldman et al., 2015; Hardt et al., 2016; Fish et al.,   \n27 2016; Woodworth et al., 2017; Zafar et al., 2017; Bechavod & Ligett, 2017; Kearns et al., 2018)   \n28 Algorithmic fairness literature aims to remedy such discrimination issues.   \n29 A machine learning algorithm satisfies the demographic parity fairness notion, if the predicted target   \n30 is independent of the sensitive attributes (Dwork et al., 2012). Promoting demographic parity can   \n31 lead to poor performance, especially if the true outcome is not independent of the sensitive attributes.   \n32 To remedy this, Hardt et al. $\\underline { { \\sqrt { 2 0 1 6 } } }$ proposed equalized odds to ensure that the predicted target is   \n33 conditionally independent of the sensitive attributes given the true label. A further relaxed version of   \n34 this notion is equal opportunity which is satisfied if predicted target is conditionally independent of   \n35 sensitive attributes given that the true label is in an advantaged class $\\textcircled { 1 } \\textcircled { 1 } \\textcircled { < } \\mathrm { a l . } \\textcircled { 2 0 1 6 } )$ . The inherent   \n36 assumption in such conditional notions is that the true labels are fair. These notions suffer from a   \n37 potential amplification of the inherent discrimination that may exist in the training data. Tackling   \n38 such bias is beyond the scope of this work; cf. Kilbertus et al. (2020) and Bechavod et al. $\\textcircled { 2 0 1 9 }$ ",
+        "bbox": [
+            147,
+            661,
+            825,
+            758
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            765,
+            825,
+            905
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/11550e4fd7633d5dd3d9fe091e75404ead349aa2331cd61684fbcc342336fcf8.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=4>Reference</td><td rowspan=1 colspan=1>NBtarget</td><td rowspan=1 colspan=1>NBattrib.</td><td rowspan=1 colspan=1>NBcode</td><td rowspan=1 colspan=3>Fairness notiondp eod eop</td><td rowspan=1 colspan=1>Beyondlogistic</td><td rowspan=1 colspan=1>Stoch. alg.(unbiased**)</td><td rowspan=1 colspan=1>Converg.(stoch.)</td></tr><tr><td rowspan=1 colspan=4>FERMI (this work)</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=2>Cho et al.</td><td rowspan=1 colspan=1>2020b</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>（x）</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=2>Cho et al.</td><td rowspan=1 colspan=1>2020a)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>×</td></tr><tr><td rowspan=1 colspan=3>Baharlouei et al.,|2020]</td><td rowspan=1 colspan=1>2020</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>了</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√（x）</td></tr><tr><td rowspan=1 colspan=3>(Rezaei et al.[2020)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>【</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>(Jiang et al.2020)*</td><td rowspan=1 colspan=1>*</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>(Mary et al..2019)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>【</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√（x）</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>Donini et al.2018]</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>X</td><td rowspan=1 colspan=1>X</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=3>Zhang et al..2018)</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1>×</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>(x)</td><td rowspan=1 colspan=1>X</td></tr></table>",
+        "bbox": [
+            173,
+            88,
+            823,
+            234
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Comparison of state-of-the-art in-processing methods. $\\mathbf { N B } =$ non-binary, $\\mathrm { d } \\mathsf { p } =$ demographic parity, eod $=$ equalized odds, $\\mathrm { { e o p = } }$ equal opportunity. While satisfying eod guarantees satisfying eop, an eod algorithm does not necessarily achieve a favorable tradeoff between performance and fairness violation in eop; we only credit those works that provide/implement algorithms for a given fairness notion. FERMI is the only method compatible with stochastic optimization and guaranteed convergence. The only existing baselines for non-binary classification with non-binary sensitive attributes are (Mary et al., 2019; Baharlouei et al., 2020; Cho et al., $\\textcircled { 2 0 2 0 6 }$ (NB code). ⇤We refer to the in-processing method of $\\mathbb { W } \\mathrm { i a n g ~ e t ~ a l . } \\backslash \\mathbb { Z } 0 2 0 \\}$ , not their post-processing method. $^ { * * } \\mathrm { W e }$ use the term “unbiased” to refer to unbiased estimation in statistical sense; it is not to be confused with bias in the fairness sense, for which we use the term discrimination. ",
+        "bbox": [
+            173,
+            239,
+            825,
+            353
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "39 Measuring fairness violation. In practice, the learner only has access to finite samples and cannot   \n40 verify demographic parity, equalized odds, or equal opportunity. This has led the machine learning   \n41 community to define several fairness violation metrics that quantify the degree of (conditional)   \n42 independence between random variables, e.g., $L _ { \\infty }$ distance (Dwork et al., 2012; Hardt et al., 2016),   \n43 mutual information (Kamishima et al., 2011; Rezaei et al., 2020; Steinberg et al., $\\mathbb { Z } 0 2 0 \\} ,$ Zhang   \n44 et al., 2018; Cho et al., 2020a), Pearson correlation (Zafar et al., $\\overline { { 2 0 1 7 } } )$ , false positive/negative rates   \n45 (Bechavod & Ligett, 2017), Hilbert Schmidt independence criterion (HSIC) (Pérez-Suay et al., 2017),   \n46 Rényi correlation (Mary et al., 2019; Baharlouei et al., 2020; Grari et al., $\\boxed { 2 0 1 9 } \\boxed { 2 0 2 0 }$ , and exponential   \n47 Rényi mutual information (ERMI) $\\boxed { \\mathrm { M a r y ~ e t ~ a l . } , \\boxed { 2 0 1 9 } }$ . In this paper, we focus on three variants of   \n48 ERMI specialized to demographic parity, equalized odds, and equal opportunity. We prove that ERMI   \n49 provides an upper bound on the rest of the above existing notions of fairness violation. Consequently,   \n50 a model trained to reduce ERMI will also provide guarantees on these other fairness violations.   \n51 We also develop a stochastic estimator for ERMI that is compatible with large-scale stochastic   \n52 optimization, and use it as a regularizer in within ERM, and call it FERMI. We theoretically show   \n53 that FERMI is convergent, and empirically demonstrate that it outperforms all other state-of-the-art   \n54 baselines, including (Mary et al., 2019) which solves the same objective as FERMI.   \n55 Related work & contributions. Fairness-promoting machine learning algorithms can be categorized   \n56 in three main classes: pre-processing, post-processing, and in-processing methods. Pre-processing   \n57 algorithms (Feldman et al., 2015; Zemel et al., 2013; Calmon et al., 2017b) transform the biased   \n58 data features to a new space in which the labels and sensitive attributes are statistically independent.   \n59 This transform is oblivious to the training procedure. Post-processing approaches (Hardt et al., 2016;   \n60 Pleiss et al., 2017) mitigate the discrimination of the classifier by altering the the final decision.   \n61 In-processing approaches focus on the training procedure and impose the notions of fairness as   \n62 constraints or regularization terms in the training procedure. Several regularization-based methods   \n63 are proposed in the literature to promote fairness in decision-trees (Kamiran et al., 2010; Raff et al.,   \n64 2018; Aghaei et al., 2019), support vector machines (Donini et al., 2018), neural networks (Grari   \n65 et al., 2020; Cho et al., 2020b), or (logistic) regression models (Zafar et al., 2017; Berk et al., 2017;   \n66 Taskesen et al., 2020; Chzhen & Schreuder, 2020; Baharlouei et al., 2020; Jiang et al., 2020; Grari   \n67 et al., 2019). While in-processing approaches generally give rise to better tradeoffs between fairness   \n68 violation and performance, existing approaches are mostly incompatible with large-scale stochastic   \n69 optimization. This paper addresses this problem. See below for a summary of our contributions and   \n70 Table 1 for a summary of the main differences between FERMI and existing in-processing methods. ",
+        "bbox": [
+            145,
+            363,
+            826,
+            585
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            590,
+            826,
+            811
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We analyze a notion of fairness violation called ERMI. We show that ERMI is a stronger notion of fairness violation than all existing notions. Therefore, a model that ensures small ERMI violation is guaranteed to have small fairness violation with respect to all other notions as well. ",
+        "bbox": [
+            161,
+            819,
+            823,
+            862
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "74 2. We formulate an empirical objective, called FERMI objective, for using ERMI as a regularizer with empirical risk minimization. We propose a solver for FERMI, which is the first stochastic in-processing fairness algorithm with guaranteed convergence. The existing stochastic fairness algorithms by Zhang et al. (2018); Mary et al. (2019); Cho et al. (2020a,b) are not guaranteed to converge. ",
+        "bbox": [
+            156,
+            869,
+            825,
+            912
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            158,
+            90,
+            826,
+            121
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3. We demonstrate through extensive numerical experiments that FERMI achieves superior fairness-accuracy tradeoff curves against all comparable baselines, even when fairness violation is measured in terms of commonly used $\\overline { { L _ { \\infty } } }$ (for demographic parity, equalized odds, and equal opportunity). In particular, the performance gap is very large when minibatch size is small (as is practically necessary for large-scale problems), and the number of sensitive attributes is large. ",
+        "bbox": [
+            173,
+            126,
+            826,
+            195
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Fairness notions: demographic parity, equalized odds, equal opportunity ",
+        "text_level": 1,
+        "bbox": [
+            163,
+            209,
+            810,
+            227
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "85 In this section, we state a notion of fairness that generalizes demographic parity, equalized odds,   \n86 and equal opportunity fairness definitions (the three notions considered in this paper). This will be   \n87 convenient for presenting our theoretical results. Consider a learner who trains a model to make   \n88 a prediction, $\\widehat { Y }$ , e.g., whether or not to extend a loan, supported on $\\mathcal { V }$ which can be discrete or   \n89 continuous. The prediction is made using a set of features, $\\mathbf { X }$ , e.g., financial history features. We   \n90 assume that there is a set of discrete sensitive attributes, $S$ , e.g., race and sex, supported on $s$ ,   \n91 associated with each sample. Further, let $\\mathcal A \\subseteq \\mathcal V$ denote an advantaged outcome class, e.g., the   \n92 outcome where a loan is extended. ",
+        "bbox": [
+            148,
+            231,
+            825,
+            344
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 1 $( Z , { \\mathcal { Z } } )$ -fairness). Given a random variable $Z$ , let $\\mathcal { Z }$ be a subset of values that $Z$ can take. We say that a learning machine satisfies $( Z , { \\mathcal { Z } } )$ -fairness if for every $z \\in { \\mathcal { Z } }$ , $\\widehat { Y }$ is conditionally independent of $S$ given $Z = z$ , i.e. $\\forall \\widehat { y } \\in \\mathcal { V } , s \\in \\mathcal { S } , z \\in \\mathcal { Z }$ , $p _ { \\widehat { Y } , S | Z } ( \\widehat { y } , s | z ) = p _ { \\widehat { Y } | Z } ( \\widehat { y } | z ) p _ { S | Z } ( s | z )$ . ",
+        "bbox": [
+            165,
+            348,
+            826,
+            395
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$( Z , { \\mathcal { Z } } )$ -fairness includes the popular demographic parity, equalized odds, and equal opportunity notions of fairness as special cases: ",
+        "bbox": [
+            165,
+            397,
+            823,
+            425
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. $( Z , { \\mathcal { Z } } )$ -fairness recovers demographic parity $\\left( { \\overline { { \\mathrm { D w o r k } \\ \\mathrm { e t } \\ \\mathrm { a l . } } } } \\right) \\left[ 2 0 1 2 \\right)$ if $Z = 0$ and ${ \\mathcal { Z } } = \\{ 0 \\}$ . In this case, conditioning on $Z$ has no effect, and hence $\\overline { { ( 0 , \\{ 0 \\} ) } }$ fairness is equivalent to the independence between $\\widehat { Y }$ and $S$ (see Definition $\\boxed { 6 }$ Appendix A) ",
+        "bbox": [
+            173,
+            429,
+            825,
+            474
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2. $( Z , { \\mathcal { Z } } )$ -fairness recovers equalized odds $\\textcircled { \\mathrm { H a r d t e t a l . } } \\textcircled { 2 0 1 6 } )$ if $Z = Y$ and $\\mathcal { Z } = \\mathcal { V }$ . In this case, $Z \\in { \\mathcal { Z } }$ is trivially satisfied. Hence, conditioning on $\\overline { Z }$ is equivalent to conditioning on $Y .$ , which recovers the equalized odds notion of fairness, i.e., conditional independence of $\\widehat { Y }$ and $S$ given $Y$ (see Definition $\\bigtriangledown$ Appendix $\\underline { { \\overline { { \\mathbf { A } } } } } )$ . ",
+        "bbox": [
+            168,
+            477,
+            820,
+            535
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3. $( Z , { \\mathcal { Z } } )$ -fairness recovers equal opportunity (Hardt et al., $\\boxed { 2 0 1 6 }$ if $Z = Y$ and $\\mathcal { Z } = \\mathcal { A }$ . This is also similar to the previous case with $\\mathcal { V }$ replaced with $\\overline { { A } }$ (see Definition 8, Appendix $\\boxed { \\mathrm { A } }$ . ",
+        "bbox": [
+            173,
+            535,
+            823,
+            565
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "07 Note that verifying $( Z , { \\mathcal { Z } } )$ -fairness requires having access to the joint distribution of random variables   \n08 $( Z , { \\widehat { Y } } , S )$ . This joint distribution is unavailable to the learner in the context of machine learning, and   \n109 hence the learner would resort to empirical estimation of the amount of violation of independence,   \n10 measured through some divergence. See (Williamson & Menon, 2019) for a related discussion. ",
+        "bbox": [
+            148,
+            568,
+            826,
+            628
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Measuring fairness violation using exponential Rényi mutual information ",
+        "text_level": 1,
+        "bbox": [
+            158,
+            638,
+            816,
+            656
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "112 Most existing fairness violations can be viewed as a (conditional) $f$ -divergence between the joint   \n113 distribution of sensitive attributes and predicted targets, $p _ { \\widehat { Y } , S | Z }$ , and the Kronecker proudct of the   \n114 marginals, $p _ { \\widehat { Y } | Z } \\otimes p _ { S | Z }$ . In this section, we focus on ERMI and show that several existing fairness   \n115 violations are upper bounded by ERMI. For brevity, we present all definitions and results $( Z , { \\mathcal { Z } } )$ .   \n116 Definition 2 (ERMI – exponential Rényi mutual information). We define the exponential Rényi   \n117 mutual information between $\\widehat { Y }$ and $S$ given $Z \\in { \\mathcal { Z } }$ as ",
+        "bbox": [
+            143,
+            660,
+            825,
+            723
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            724,
+            825,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/11b1def83d1cea199c31a8258fcf8acc1adedee8ba465436fc1e15dbc91d8f69.jpg",
+        "text": "$$\n\\begin{array} { r } { D _ { R } ( \\widehat { Y } ; S | Z \\in \\mathcal { Z } ) : = \\mathbb { E } _ { Z , \\widehat { Y } , S } \\left\\{ \\left. \\frac { p _ { \\widehat { Y } , S | Z } ( \\widehat { Y } , S | Z ) } { p _ { \\widehat { Y } | Z } ( \\widehat { Y } | Z ) p _ { S | Z } ( S | Z ) } \\right| Z \\in \\mathcal { Z } \\right\\} - 1 . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            758,
+            714,
+            799
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "118 In Appendix $\\bigtriangledown$ we unravel the definition for the special cases of interest corresponding to demo  \n119 graphic parity, equalied odds, and equal opportunity. We also discuss that ERMI is the $\\chi ^ { 2 }$ -divergence   \n120 (which is an $f$ -divergence) between the joint distribution, $p _ { \\widehat { Y } , S | Z }$ , and the Kronecker product of   \n121 marginals, $p _ { \\widehat { Y } | Z } \\otimes p _ { S | Z } \\ \\mathrm { ( f C a l m o n \\ e t \\ a l . ) } \\mathrm { [ 2 0 1 7 a ] }$ . In particular, ERMI is non-negative, and zero if   \n122 and only if $( Z , { \\mathcal { Z } } )$ -fairness is satisfied. In the context of algorithmic fairness, ERMI was first used   \n123 by $\\boxed { \\mathrm { M a r y ~ e t ~ a l . } } \\textcircled { 2 0 1 9 }$ as a regularizer. We will provide a new stochastic solver/estimator for ERMI,   \n124 which theoretically converges and empirically outperforms the one by Mary et al. $\\textcircled { 2 0 1 9 }$ .   \n125 Definition 3 (Rényi mutual information (Rényi, 1961)). Let the Rényi mutual information of order   \n126 $\\alpha > 1$ between random variables $\\widehat { Y }$ and $S$ given $Z \\in { \\mathcal { Z } }$ be defined as: ",
+        "bbox": [
+            140,
+            806,
+            826,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            89,
+            825,
+            122
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1aabea13018878a456f459d33ce152a1235c4526d536a357823b96c0f18e30e5.jpg",
+        "text": "$$\nI _ { \\alpha } ( \\widehat { Y } ; S | Z \\in \\mathcal { Z } ) : = \\frac { 1 } { \\alpha - 1 } \\log \\left( \\mathbb { E } _ { z , \\widehat { Y } , S } \\left\\{ \\left. \\left( \\frac { p _ { \\widehat { Y } , S | Z } ( \\widehat { Y } , S | Z ) } { p _ { \\widehat { Y } | Z } ( \\widehat { Y } | Z ) p _ { S | Z } ( S | Z ) } \\right) ^ { \\alpha - 1 } \\right| Z \\in \\mathcal { Z } \\right\\} \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            210,
+            126,
+            746,
+            170
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "127 which generalizes Shannon mutual information ",
+        "bbox": [
+            142,
+            172,
+            490,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/72177bbf24c2f16987f1989b6c984eacc3284ff370f1b7d77dfe1ae00c3220d8.jpg",
+        "text": "$$\nI _ { 1 } ( \\widehat { Y } ; S | Z \\in \\mathcal { Z } ) : = \\mathbb { E } _ { Z , \\widehat { Y } , S } \\left\\{ \\log \\left( \\frac { p _ { \\widehat { Y } , S | Z } ( \\widehat { Y } , S | Z ) } { p _ { \\widehat { Y } | Z } ( \\widehat { Y } | Z ) p _ { S | Z } ( S | Z ) } \\right) \\Bigg | Z \\in \\mathcal { Z } \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            190,
+            718,
+            231
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "128 and recovers it as $\\begin{array} { r } { \\operatorname* { l i m } _ { \\alpha  1 ^ { + } } I _ { \\alpha } ( \\widehat { Y } ; S | Z \\in \\mathcal { Z } ) = I _ { 1 } ( \\widehat { Y } ; S | Z \\in \\mathcal { Z } ) . } \\end{array}$ . ",
+        "bbox": [
+            147,
+            236,
+            584,
+            252
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "29 Note that $I _ { \\alpha } ( \\widehat { Y } ; S | Z \\in \\mathcal { Z } ) \\geq 0$ with equality if and only if $( Z , { \\mathcal { Z } } )$ -fairness is satisfied. ",
+        "bbox": [
+            151,
+            261,
+            730,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "130 Theorem 1 (ERMI is stronger than Shannon mutual information). We have ",
+        "bbox": [
+            147,
+            280,
+            681,
+            295
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3c36868d9e68c3c2a380bc31b7825498feb56a0543109bd9c5ef7fbf47eb1c99.jpg",
+        "text": "$$\n0 \\le I _ { 1 } ( \\widehat { Y } ; S | Z \\in \\mathcal { Z } ) \\le I _ { 2 } ( \\widehat { Y } ; S | Z \\in \\mathcal { Z } ) \\le e ^ { I _ { 2 } ( \\widehat { Y } ; S | Z \\in \\mathcal { Z } ) } - 1 = D _ { R } ( \\widehat { Y } ; S | Z \\in \\mathcal { Z } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            241,
+            297,
+            754,
+            319
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "132 All proofs are relegated to the appendix. Theorem $\\bigstar$ establishes that ERMI is a stronger measure of   \n133 fairness violation in the sense that driving it to zero would also bound the Shannon mutual information,   \n134 which is used for promoting fairness in recent literature $\\mathbb { ( C h o e t a l . , } \\mathbb { Z 0 2 0 a ) }$ . It also shows that ERMI   \n135 is exponentially related to the Rényi mutual information of order 2.   \n136 Definition 4 (Rényi correlation (Hirschfeld, 1935; Gebelein, 1941; Rényi, 1959)). Let $\\mathcal { F }$ and $\\mathcal { G }$   \n137 be the set of measurable functions such that for random variables $\\widehat { Y }$ and $S$ , $\\overline { { { \\mathbb { E } } } } _ { \\widehat { Y } } \\{ f ( \\widehat { Y } ; z ) \\} \\ =$   \n138 $\\mathbb { E } _ { S } \\left\\{ g ( S ; z ) \\right\\} = 0 ,$ , $\\mathbb { E } _ { \\widehat { Y } } \\{ f ( \\widehat { Y } ; z ) ^ { 2 } \\} = \\mathbb { E } _ { S } \\left\\{ g ( S ; z ) ^ { 2 } \\right\\} = 1$ , for all $z \\in { \\mathcal { Z } }$ . Rényi correlation is: ",
+        "bbox": [
+            142,
+            332,
+            825,
+            388
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            391,
+            826,
+            443
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a15bbb84d6070b9aea0c70ee0fd41736f6e92bf99394f428fb83abbeac850491.jpg",
+        "text": "$$\n\\begin{array} { r } { \\rho _ { R } ( \\widehat { Y } , S | Z \\in \\mathcal { Z } ) : = \\underset { f , g \\in \\mathcal { F } \\times \\mathcal { G } } { \\operatorname* { s u p } } \\ \\mathbb { E } _ { Z , \\widehat { Y } , S } \\left\\{ \\left. f ( \\widehat { Y } ; Z ) g ( S ; Z ) \\right| Z \\in \\mathcal { Z } \\right\\} . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            455,
+            692,
+            484
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "139 ",
+        "bbox": [
+            142,
+            479,
+            161,
+            489
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "140 Rényi correlation generalizes Pearson correlation, ",
+        "bbox": [
+            142,
+            492,
+            501,
+            507
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d4453ff20c0fd1d58bba0d47ce6ba27c00989503176bf5ea6db652eba6781631.jpg",
+        "text": "$$\n\\rho ( \\widehat { Y } , S | Z \\in \\mathcal { Z } ) : = \\mathbb { E } _ { Z } \\left\\{ \\left. \\frac { \\mathbb { E } _ { \\widehat { Y } , S } \\{ \\widehat { Y } S | Z \\} } { \\sqrt { \\mathbb { E } _ { \\widehat { Y } } \\{ \\widehat { Y } ^ { 2 } | Z \\} \\mathbb { E } _ { S } \\{ S ^ { 2 } | Z \\} } } \\right| Z \\in \\mathcal { Z } \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            506,
+            689,
+            554
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "141 ",
+        "bbox": [
+            142,
+            551,
+            160,
+            560
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "142 to capture nonlinear dependencies between the random variables by finding functions of random   \n143 variables that maximize the Pearson correlation coefficient between the random variables. In fact,   \n144 it is true that $\\rho _ { R } ( \\widehat { Y } , S | Z \\in \\mathcal { Z } ) \\geq 0$ with equality if and only if $( Z , { \\mathcal { Z } } )$ -fairness is satisfied. Rényi   \n145 correlation has gained popularity as a measure of fairness violation (Mary et al., 2019; Baharlouei   \n146 et al., $\\boxed { 2 0 2 0 }$ Grari et al., 2020). Rényi correlation is also upper bounded by ERMI. The following   \n147 result has already been shown by Mary et al. $\\textcircled { | 2 0 1 9 }$ and we present it for completeness. ",
+        "bbox": [
+            140,
+            558,
+            826,
+            645
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "148 Theorem 2 (ERMI is stronger than Rényi correlation). We have ",
+        "bbox": [
+            148,
+            647,
+            594,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ff20ef6eef2f391578570f4d4f3df0f3a92f8535932a54211d22dd18ff4ef626.jpg",
+        "text": "$$\n0 \\le | \\rho ( \\widehat { Y } , S | Z \\in \\mathcal { Z } ) | \\le \\rho _ { R } ( \\widehat { Y } , S | Z \\in \\mathcal { Z } ) \\le D _ { R } ( \\widehat { Y } ; S | Z \\in \\mathcal { Z } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            666,
+            710,
+            686
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "149 and if $| S | = 2$ , $D _ { R } ( \\widehat { Y } ; S | Z \\in \\mathcal { Z } ) = \\rho _ { R } ( \\widehat { Y } , S | Z \\in \\mathcal { Z } ) .$ ",
+        "bbox": [
+            142,
+            696,
+            534,
+            715
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "150 Definition 5 ( $L _ { q }$ fairness violation). We define the $L _ { q }$ fairness violation for $q \\geq 1$ by: ",
+        "bbox": [
+            137,
+            717,
+            736,
+            732
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cf36a08fa37d2fcfad9bf72fd362c316fcf029f976c1bec52abb28fc4d4fb3fc.jpg",
+        "text": "$$\nL _ { q } ( \\widehat { Y } , S | Z \\in \\mathcal { Z } ) : = \\mathbb { E } \\mathcal { Z } \\Bigg \\{ \\Bigg ( \\int _ { \\widehat { y } \\in \\mathcal { Y } _ { 0 } } \\sum _ { s \\in \\mathcal { S } _ { 0 } } \\left| p _ { \\widehat { Y } , S | Z } ( \\widehat { y } , s | Z ) - p _ { \\widehat { Y } | Z } ( \\widehat { y } | Z ) p _ { S | Z } ( s | Z ) \\right| ^ { q } d y \\Bigg ) ^ { \\frac { 1 } { q } } \\Bigg | Z \\in \\mathcal { Z } \\Bigg \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            736,
+            803,
+            780
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "151 Note that $L _ { q } ( \\widehat { Y } , S | Z \\in \\mathcal { Z } ) = 0$ if and only if $( Z , { \\mathcal { Z } } )$ -fairness is satisfied. In particular, $L _ { \\infty }$ fairness   \n152 violation recovers demographic parity violation $( \\overline { { \\mathrm { K e a r n s ~ e t ~ a l . } } } , \\overline { { 2 0 1 8 } } ,$ Definition 2.1) if we let $\\mathcal { Z } = \\{ 0 \\}$   \n153 and $Z = 0$ . It also recovers equal opportunity violation (Hardt et al., 2016) if ${ \\mathcal { Z } } = A$ and $Z = Y$ .   \n154 Theorem 3 (ERMI is stronger than $L _ { \\infty }$ fairness violation). Let $\\widehat { Y }$ be a discrete or continuous random   \n155 variable, and $S$ be a discrete random variable supported on a finite set. Then for any $q \\geq 1$ , ",
+        "bbox": [
+            140,
+            806,
+            825,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            853,
+            821,
+            883
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/387886d7f125f40bd6ab77138c0e1a53b0a1feb43b182d0b87f1e311a79c437a.jpg",
+        "text": "$$\n0 \\leq L _ { q } ( \\widehat { Y } , S | Z \\in \\mathcal { Z } ) \\leq \\sqrt { D _ { R } ( \\widehat { Y } , S | Z \\in \\mathcal { Z } ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            887,
+            651,
+            915
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "157 The above theorem says that if a method controls ERMI value for imposing fairness, then $L _ { \\infty }$   \n158 violation is controlled. In particular, the variant of ERMI that is specialized to demographic parity   \n159 also controls $L _ { \\infty }$ demographic parity violation $\\mathrm { ( \\overline { { K e a r n s \\ e t \\ a l . } } , \\overline { { 2 0 1 8 } } ) }$ . The variant of ERMI that is   \n160 specialized to equal opportunity also controls the $\\overline { { L _ { \\infty } } }$ equal opportunity violation $\\mathbb { ( H a r d t e t a l . } ) \\mathbb { 2 0 1 6 ) }$ .   \n161 While our algorithm uses ERMI as a regularizer, in our experiments, we measure fairness violation   \n162 through the more commonly used $L _ { \\infty }$ violation. Despite this, we show that our approach leads to   \n163 better tradeoff curves between fairness violation and performance.   \n164 Remark. The bounds in Theorems 1-3 are not tight in general, but this is not of practical concern.   \n165 They show that bounding ERMI is sufficient because any model that achieves small ERMI is   \n166 guaranteed to satisfy any other fairness violation. This makes ERMI an effective regularizer for   \n167 promoting fairness. In fact, in Sec. $\\bigtriangledown$ we see that the proposed algorithm, FERMI, achieves the best   \n168 tradeoffs between fairness violation and performance across state-of-the-art baselines. ",
+        "bbox": [
+            140,
+            90,
+            825,
+            189
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            194,
+            825,
+            265
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "69 4 FERMI: fair empirical risk minimization through ERMI regularization ",
+        "text_level": 1,
+        "bbox": [
+            156,
+            276,
+            803,
+            295
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "170 Our goal is to train a model that balances fairness and accuracy objectives. To this end, we introduce fair risk minimization through exponential Rényi mutual information framework defined below:1 171 ",
+        "bbox": [
+            148,
+            299,
+            823,
+            328
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f5079b2288a0b450639332f6207c47ef5db1c926505fe05822893ef855faa9df.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\pmb { \\theta } } \\left\\{ \\mathrm { F R M I } ( \\pmb { \\theta } ) : = \\mathbb { E } _ { \\mathbf { X } , Y , S } \\left\\{ \\ell \\big ( \\mathbf { X } , Y ; \\pmb { \\theta } \\big ) \\right\\} + \\lambda D _ { R } \\big ( \\widehat { Y } ( \\mathbf { X } ; \\pmb { \\theta } ) ; S \\big ) \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            334,
+            676,
+            362
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(FRMI obj.) ",
+        "bbox": [
+            740,
+            340,
+            823,
+            356
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "172 where $\\ell$ denotes the loss function, such as $L _ { 2 }$ loss or cross entropy loss; $\\lambda > 0$ is a scalar balancing   \n173 the accuracy versus fairness objectives; ${ D _ { R } \\big ( \\widehat { Y } ( { \\mathbf { X } } ; { \\pmb \\theta } ) ; { S } \\big ) }$ is the notion of ERMI given in Eq. (ERMI)   \n174 particularized to demographic parity (see Eq. (5)); and $\\widehat { Y } ( \\mathbf { X } ; \\pmb { \\theta } )$ is the output of the learned model   \n175 (e.g., the output of a classification or a regression task, or the cluster number in a clustering task).   \n176 While $\\widehat { Y } ( \\mathbf { X } ; \\pmb { \\theta } )$ inherently depends on $\\mathbf { X }$ and $\\pmb { \\theta }$ , in the rest of this paper, we sometimes leave the   \n177 dependence of $\\widehat { Y }$ on $\\mathbf { X }$ and/or $\\pmb \\theta$ implicit for brevity of notation. Notice that we have also left the   \n178 dependence of the loss on the predicted outcome $\\widehat { Y }$ implicit.   \n179 In practice, the true joint distribution of $( \\mathbf { X } , S , Y , { \\widehat { Y } } )$ is unknown and we only have $N$ samples at   \n180 our disposal, making it impossible to solve FRMI. Let $\\{ \\mathbf { x } _ { i } , s _ { i } , y _ { i } , \\widehat { y } _ { i } ( \\mathbf { x } _ { i } ; \\pmb { \\theta } ) \\} _ { i \\in [ N ] }$ denote the features,   \n181 sensitive attributes, targets, and the predictions of the model parameterized by $\\mathbf { \\bar { \\theta } }$ for these samples.   \n182 $\\boxed { \\mathrm { M a r y ~ e t ~ a l . } } ( \\boxed { 2 0 1 9 } )$ considered the same objective Eq. $( \\mathrm { F R M I \\hat { o } b j . } )$ , and tried to empirically solve it   \n183 through a kernel approximation. We propose a completely different approach to solving this problem:   \n184 fair empirical risk minimization via exponential Rényi mutual information (FERMI). FERMI results   \n185 in a provably convergent algorithm, and empirically outperforms the algorithm by $\\boxed { \\mathrm { M a r y ~ e t ~ a l . } } \\textcircled { 2 0 1 9 }$   \n186 It is straightforward to derive an unbiased estimate for $\\mathbf { \\bar { E } } _ { \\mathbf { X } , Y , S } \\left\\{ \\ell ( \\mathbf { X } , \\mathbf { \\bar { Y } } ; \\pmb { \\theta } ) \\right\\}$ through the empirical   \n187 risk, e.g., $\\begin{array} { r } { \\frac { 1 } { | B | } \\sum _ { i \\in B } \\ell \\big ( \\mathbf { x } _ { i } , y _ { i } ; \\pmb { \\theta } \\big ) } \\end{array}$ where $B \\subseteq [ N ]$ is a random minibatch of data points. However,   \n188 estimating $D _ { R } ( \\widehat { Y } , S )$ in the objective function in Eq. $( \\mathrm { F R M I ~ o b j . } )$ is more difficult. In what follows,   \n189 we present our approach to deriving an unbiased stochastic estimator of $D _ { R } ( \\widehat { Y } , S )$ given a random   \n190 batch of data points $B$ . The following theorem is the key tool we use to obtain an unbiased estimator: ",
+        "bbox": [
+            140,
+            368,
+            826,
+            482
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            487,
+            826,
+            667
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "191 Theorem 4. For discrete random variables $\\widehat { Y } = \\widehat { Y } ( \\mathbf { X } ; \\pmb { \\theta } )$ and $S$ where $\\widehat { Y } \\in [ m ] , S \\in [ k ]$ , we have ",
+        "bbox": [
+            143,
+            671,
+            821,
+            690
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f4955a742cf60d4c17168d6e85637deb0162ec6bbaff20d46982bb07d1fe5dfb.jpg",
+        "text": "$$\nD _ { R } ( \\widehat { Y } ; S ) = \\operatorname* { m a x } _ { W \\in \\mathbb { R } ^ { k \\times m } } \\Big \\{ - \\operatorname { T r } ( W P _ { \\widehat { y } } W ^ { T } ) + 2 \\operatorname { T r } ( W P _ { \\widehat { y } , s } P _ { s } ^ { - 1 / 2 } ) - 1 \\Big \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            263,
+            695,
+            733,
+            724
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "192 where $P _ { \\widehat { \\cal Y } } = \\mathrm { d i a g } ( p _ { \\widehat { \\cal Y } } ( 1 ) , \\ldots , p _ { \\widehat { \\cal Y } } ( m ) )$ , $P _ { s } = \\mathrm { d i a g } ( p _ { S } ( 1 ) , \\dots , p _ { S } ( k ) )$ , and ",
+        "bbox": [
+            142,
+            731,
+            669,
+            750
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/20230cb2d5c3423ecc42a49436cd9fd108a067fbad20ff40f0aa3458210174ae.jpg",
+        "text": "$$\nP _ { \\widehat { y } , s } = \\left( \\begin{array} { c c c } { p _ { \\widehat { Y } , S } ( 1 , 1 ) } & { \\ldots } & { p _ { \\widehat { Y } , S } ( 1 , k ) } \\\\ { \\vdots } & { \\ddots } & { \\vdots } \\\\ { p _ { \\widehat { Y } , S } ( m , 1 ) } & { \\ldots } & { p _ { \\widehat { Y } , S } ( m , k ) } \\end{array} \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            755,
+            645,
+            814
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Let 193 $\\widehat { \\mathbf Y }$ , $\\widehat { \\mathbf { y } } _ { i } \\in \\{ 0 , 1 \\} ^ { m }$ and S, $\\mathbf { s } _ { i } \\in \\{ 0 , 1 \\} ^ { k }$ be the one-hot encodings of $\\widehat { Y } , \\widehat { y } _ { i }$ and $S , s _ { i }$ , respectively. b b194 Then, the above theorem implies that we can compute an unbiased estimate of Eq. (FRMI obj.): ",
+        "bbox": [
+            143,
+            827,
+            826,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "195 Lemma 1 (Unbiased estimator of ERMI). Let $( \\mathbf { X } , S , Y , \\widehat { Y } ( \\mathbf { X } ; \\pmb { \\theta } ) )$ be a random draw from $P _ { { \\bf X } , S , Y , \\widehat { Y } }$   \n196 Further, let ",
+        "bbox": [
+            143,
+            89,
+            826,
+            121
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/59c8e9476c71089d37840c005b45926d325d528214140af03a2a5755e3d0bb44.jpg",
+        "text": "$$\n\\begin{array} { r } { \\psi ( { \\mathbf { X } } , S , Y , \\widehat { Y } ; \\pmb { \\theta } , W ) : = - \\operatorname { T r } ( W \\widehat { \\mathbf { Y } } ( { \\mathbf { X } } ; \\pmb { \\theta } ) \\widehat { \\mathbf { Y } } ^ { T } ( { \\mathbf { X } } ; \\pmb { \\theta } ) W ^ { T } ) + 2 \\operatorname { T r } ( W \\widehat { \\mathbf { Y } } ( { \\mathbf { X } } ; \\pmb { \\theta } ) { \\mathbf { S } } ^ { T } P _ { s } ^ { - 1 / 2 } ) - 1 . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            125,
+            784,
+            143
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "197198 Then, $\\operatorname* { m a x } _ { W \\in \\mathbb { R } ^ { k \\times m } } \\psi ( \\mathbf { X } , S , Y , \\widehat { Y } ; \\pmb { \\theta } , W )$ is an unbiased estimator of ERMI in Eq. (FRMI obj.), i.e., ",
+        "bbox": [
+            140,
+            156,
+            826,
+            175
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c39aa9dabea733611cf1a5b3555b34f8f9585fc16da872b8068b7febc7d5ddf0.jpg",
+        "text": "$$\n\\mathbb { E } _ { { \\mathbf { X } } , S , Y } \\Big \\{ \\operatorname* { m a x } _ { W \\in \\mathbb { R } ^ { k \\times m } } \\psi ( { \\mathbf { X } } , S , Y , \\widehat { Y } ; \\pmb { \\theta } , W ) \\Big \\} = D _ { R } ( \\widehat { Y } ( { \\mathbf { X } } ; \\pmb { \\theta } ) ; S ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            179,
+            700,
+            207
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "199200 The stochastic estimator, $\\psi ( { \\mathbf { X } } , S , Y , \\widehat { Y } ; \\pmb { \\theta } , W )$ , in Lemma $\\boxed { 1 }$ requires the knowledge of $P _ { s }$ , and   \n201 computation of $P _ { s } ^ { - 1 / 2 }$ . This can be estimated with high fidelity (for small to moderate sensitive set)   \n202 through a single initial pass over the entire dataset in practice. Hence, we consider it to be known.   \n203 Now, we are equipped to state the empirical objective function that we solve in this paper: ",
+        "bbox": [
+            140,
+            209,
+            828,
+            273
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/734a4aeb88a1789b0583b553274c31f930eaf411a2cfbcbf779af8a3b9f60fb8.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\operatorname* { m a x } _ { W \\in \\mathbb { R } ^ { k \\times m } } \\left\\{ \\mathrm { F E R M I } ( \\theta , W ) : = \\frac { 1 } { N } \\sum _ { i \\in [ N ] } \\left[ \\ell ( \\mathbf { x } _ { i } , y _ { i } ; \\theta ) + \\lambda \\psi _ { i } ( \\pmb { \\theta } , W ) \\right] \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            210,
+            277,
+            694,
+            328
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "204 where ",
+        "bbox": [
+            140,
+            332,
+            217,
+            345
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b589cbb88ac465663b88ece1d8ad79994d86e2c58540556cc3dbe5b300901828.jpg",
+        "text": "$$\n\\psi _ { i } ( \\pmb \\theta , W ) : = - \\operatorname { T r } ( W \\widehat { \\mathbf y } _ { i } ( \\mathbf x _ { i } ; \\pmb \\theta ) \\widehat { \\mathbf y } _ { i } ^ { T } ( \\mathbf x _ { i } ; \\pmb \\theta ) W ^ { T } ) + 2 \\operatorname { T r } ( W \\widehat { \\mathbf y } _ { i } ( \\mathbf x _ { i } ; \\pmb \\theta ) \\mathbf s _ { i } ^ { T } P _ { s } ^ { - 1 / 2 } ) - 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            228,
+            349,
+            767,
+            369
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "205 In particular, Lemma $^ 1$ says that, for any $N$ , Eq. $\\mathrm { ( F E R M I o b j . ) }$ (and its gradients) is an unbiased and   \n206 consistent estimator of the Eq. $( \\mathrm { F R M I } \\ \\mathrm { o b j . } )$ objective function (and its gradients) by an empirical   \n207 average over the minibatch. This is in contrast to the density estimation methods used by Mary et al.   \n208 $\\bar { ( 2 0 1 9 ) }$ and Baharlouei et al. $\\underline { { \\textregistered 2 0 2 0 } }$ , which are biased but consistent. We will see in the experiments   \n209 that the unbiased estimator empirically offers large performance improvements. ",
+        "bbox": [
+            140,
+            373,
+            828,
+            444
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "210 This observations leads us to deriving a stochastic algorithm, presented in Algorithm $\\mathbb { L } ,$ which is guaranteed to converge for any batch size $1 \\le | B | \\le \\bar { N }$ since the stochastic gradients are unbiased. ",
+        "bbox": [
+            143,
+            449,
+            825,
+            479
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 (FERMI Algorithm). Two-Time Scale SGDA for solving FERMI objective ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            493,
+            759,
+            508
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1: Input: $\\pmb { \\theta } ^ { 0 } \\in \\mathbb { R } ^ { d _ { \\theta } }$ , $W ^ { 0 } \\in \\mathcal { W } \\subset \\mathbb { R } ^ { k \\times m }$ , step-sizes $( \\eta _ { \\theta } , \\eta _ { w } )$ , mini-batch $B \\subseteq [ N ]$ , fairness   \nparameter $\\lambda \\geq 0$ , iteration number $R$ .   \n2: for $t = 0 , 1 , \\ldots , R$ do   \n3: 4: Set Draw a mini-batch $\\begin{array} { r l } & { \\mathrm { ~ \\it ~ N ~ a ~ m m u n - b a t c h ~ \\it ~ B ~ o ~ f ~ d a t a ~ p o m t s ~ \\{ ~ ( x _ { i } , ~ { s _ { i } } , ~ { y _ { i } } ) \\} _ { i \\in \\it B } } } \\\\ & { \\mathrm { ~ \\it ~ \\beta ^ { t + 1 } ~  ~ } \\theta ^ { t } - \\frac { \\eta _ { \\theta } } { | \\it B | } \\sum _ { i \\in \\it B } [ \\nabla _ { \\theta } \\ell ( { \\bf x } _ { i } , y _ { i } ; \\theta ^ { t } ) + \\lambda \\nabla _ { \\theta } \\psi _ { i } ( \\theta ^ { t } , W ^ { t } ) ] . } \\\\ & { \\mathrm { ~ \\it ~ W ^ { t + 1 } ~  ~ } \\Pi _ { \\mathcal { W } } \\Big ( W ^ { t } + \\frac { 2 \\lambda \\eta _ { w } } { | \\it B | } \\sum _ { i \\in \\it B } \\Big [ - W \\hat { \\bf y } _ { i } ( { \\bf x } _ { i } ; \\theta ^ { t } ) \\hat { \\bf y } _ { i } ^ { T } ( { \\bf x } _ { i } ; \\theta ^ { t } ) + P _ { s } ^ { - 1 / 2 } { \\bf s } _ { i } \\hat { \\bf y } _ { i } ^ { T } ( { \\bf x } _ { i } ; \\theta ^ { t } ) \\Big ] \\Big ) } \\end{array}$ of data points   \n5: Se   \n6: end for   \n7: Pick $\\hat { t }$ uniformly at random from $\\{ 1 , \\ldots , R \\}$ .   \n8: Return: $\\theta ^ { \\hat { t } }$ . ",
+        "bbox": [
+            178,
+            511,
+            823,
+            650
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "212 Theorem 5. (Informal statement) Algorithm 1 converges to the set of ✏-first order stationary points of the Eq. (FERMI obj.) objective in 213 $\\textstyle { \\check { O } } ( { \\frac { 1 } { \\epsilon ^ { 4 } } } )$ iterations (stochastic gradient evaluations). ",
+        "bbox": [
+            150,
+            665,
+            825,
+            696
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The formal statement of this theorem can be found in Theorem $\\boxed { 1 0 }$ in Appendix D. A faster convergence rate of $O ( \\textstyle { \\frac { 1 } { \\epsilon ^ { 3 } } } )$ could be obtained by using the (more complicated) SREDA method of Luo et al. (2020) instead of SGDA to solve FERMI objective. We omit the details here. In the next section, we numerically evaluate the performance FERMI algorithm in several numerical experiments. ",
+        "bbox": [
+            171,
+            704,
+            825,
+            761
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Numerical experiments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            772,
+            401,
+            789
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 Binary classification and binary sensitive attribute ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            795,
+            562,
+            810
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For our first set of experiments, we evaluate the fairness-accuracy tradeoffs of FERMI in binary classification problems with a binary sensitive attribute. This is a common setup, so we are able to compare against many existing baseline methods (Zafar et al., 2017; Feldman et al., 2015; Kamishima et al., 2011; Jiang et al., 2020; Hardt et al., 2016; Baharlouei et al., 2020; Rezaei et al., 2020; Donini et al., 2018; Cho et al., 2020b). We run experiments on three data sets: Adult, German Credit, and COMPAS. To implement FERMI, we train a logistic regression model (same model for all baselines) with an ERMI regularizer. Details about the datasets and experiments can be found in Appendix E. ",
+        "bbox": [
+            169,
+            814,
+            825,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/9f773481d07b948211dc9a8cffebaad609a31409505d8e15bec2e7c529c5424c.jpg",
+        "image_caption": [
+            "Figure 1: Binary classification with binary sensitive attribute using logistic regression. Tradeoff of fairness violation vs. test error for state-of-the-art fair classifiers on German Credit, Adult, and COMPAS datasets. FERMI offers the best fairness vs. accuracy tradeoff curve in all experiments against all baselines. Rezaei et al. $\\left( \\left| 2 0 2 0 \\right. \\right.$ only allow for a single output and do not yield a tradeoff curve. Further, the algorithms by Mary et al. (2019) and Baharlouei et al. $] ( \\underline { { 2 0 2 0 } } )$ are equivalent in this binary setting and shown by the red curve. FERMI, Mary et al. $\\overline { { ( 2 0 1 9 ) } }$ and Baharlouei et al. $\\dot { ( 2 0 2 0 ) }$ try to empirically solve the same risk function Eq. $\\underline { { \\operatorname { \\mathrm { ( F R M I } } } }$ obj.). However, the empirical formulation used by FERMI, Eq. $\\mathrm { ( \\mathbb { F } E R M I o b j . ) }$ and its solver result in a better performance even-though we are using a full-batch for all baselines in this experiment. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            816,
+            482
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 1, we report the fairness violation vs. test error, for three notions of fairness: demographic parity, equalized odds, and equal opportunity. We have only included in-processing methods, which outperform pre-processing and post-processing methods. Complete experimental results are included in the appendix. We measure fairness violation through conditional demographic parity $L _ { \\infty }$ violation (Definition 9), conditional equal opportunity $L _ { \\infty }$ violation (Definition $\\bar { 1 0 ) }$ and its generalization, conditional equalized odds violation. As can be seen, FERMI offers a fairness-accuracy tradeoff curve that dominates all existing state-of-the-art baselines in each experiment and with respect to each notion of fairness. This demonstrates the efficacy of having a strong regularizer such as ERMI: by enforcing small ERMI violation, our model simultaneously achieves small fairness violation with respect to these other notions which are upper bounded by ERMI. ",
+        "bbox": [
+            160,
+            599,
+            825,
+            739
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "It is noteworthy that the empirical objective function of $\\boxed { \\mathrm { M a r y ~ e t ~ a l . } } \\textcircled { 2 0 1 9 }$ and Baharlouei et al. $\\underline { { \\textregistered 0 2 0 } } )$ is exactly the same in this setting, and their algorithms also coincide to the red curve in Fig. 1. 2 Additionally, like FERMI, they are trying to empirically solve Eq. (FRMI obj.), albeit using different estimation techniques, i.e., their empirical objective is different from Eq. (FERMI obj.). This demonstrates the effectiveness of our empirical formulation (FERMI obj.) – which is both unbiased and consistent whereas theirs is biased. It also shows the effectiveness of our solver (Algorithm 1) even-though we are using all baselines in full batch mode in this experiment. In the following experiments, we will demonstrate that using smaller batch sizes results in much more pronounced advantages of FERMI over these baselines. ",
+        "bbox": [
+            171,
+            744,
+            826,
+            869
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b3cdbe721450ac272cb641aad83b868a5e75312be9b78dae7e732110db27f388.jpg",
+        "image_caption": [
+            "Figure 2: Comparison between FERMI, Mary et al. $\\textcircled { 2 0 1 9 }$ , Baharlouei et al. $\\underline { { \\textregistered 0 2 0 } }$ , and Cho et al. $\\textcircled { 2 0 2 0 6 }$ o n Communities dataset. (Mary et al., 2019) outperforms (Baharlouei et al., 2020; Cho et al., 2020b) which we believe could be attributed to the effectiveness of ERMI as a regularizer. FERMI outperforms Mary et al. $\\textcircled { 2 0 1 9 }$ , which we attribute to our empirical formulation of ERMI and the effectiveness of its solver, given that we try to empirically solve the same risk function with different formulations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            94,
+            815,
+            290
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 5.2 Non-binary fair classification with a non-binary sensitive attribute ",
+        "text_level": 1,
+        "bbox": [
+            158,
+            369,
+            673,
+            385
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Next, we consider a non-binary classification problem with non-binary sensitive set. In this case, we consider the Communities and Crime dataset, which has 18 binary sensitive attributes in total, and we pick a subset of $1 , 2 , 3 , \\ldots , 1 8$ sensitive attributes out of those for our experiments, which corresponds to $| S | \\in \\{ 2 , 4 , 8 , \\dots , 2 ^ { 1 8 } \\}$ . We discretize the target into three classes $\\{ \\mathrm { h i g h }$ , medium, $\\left. { l o w } \\right\\}$ . The only baselines that we are aware of that can handle non-binary classification with non-binary sensitive attributes are (Mary et al., 2019), (Baharlouei et al., 2020), (Cho et al., 2020b), (Cho et al., 2020a), and (Zhang et al., 2018). We used the publicly available implementations of (Baharlouei et al., 2020) and (Cho et al., 2020b) and extended their binary classification algorithms to the non-binary setting. ",
+        "bbox": [
+            173,
+            390,
+            826,
+            501
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results are presented in Fig. $^ { 2 , }$ where we use conditional demographic parity $L _ { \\infty }$ violation (Definition 9) and conditional equal opportunity $L _ { \\infty }$ violation (Definition $\\bar { 1 0 } )$ as the fairness violation notions for the two experiments. For all baselines, test error increases as the number of sensitive attributes increases. As can be seen, compared to the baselines, FERMI offers the most favorable test error vs. fairness violation tradeoffs, particularly as the number of sensitive attributes increases and for the more stringent fairness violation levels, e.g., 0.02. ",
+        "bbox": [
+            173,
+            506,
+            825,
+            590
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 Domain generalization through FERMI ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            602,
+            488,
+            617
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In our last experiment, our goal is to showcase the efficacy of FERMI in stochastic optimization with neural network approximation. For this experiment, we consider the Color MNIST dataset $\\operatorname { \\mathbb { E } i } \\ \\&$ Vasconcelos, 2019), where all 60,000 training MNIST digits are colored with different colors drawn from a class conditional Gaussian distribution with variance $\\sigma$ around a certain average color for each digit, while the test set remains black and white. $\\operatorname { L i } \\ \\& \\ \\operatorname { V a s c o n c e l o s } \\left( \\beta 0 1 9 \\right)$ show that as $\\sigma  0$ , a convolutional network model overfits significantly to each digit’s color on the training set, and achieves vanishing training accuracy. However, the learned representation does not generalize to the regular black and white test set, in absence of the spurious correlation between digits and color. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            733
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "270 Conceptually, the goal of the classifier in this problem is to achieve high classification accuracy with   \n271 predictions that are independent of the color of the digit. We view color as the sensitive attribute   \n272 in this experiment, and apply fairness baselines for the demographic parity notion of fairness. One   \n273 would expect that by promoting such independence through a fairness regularizer generalization   \n274 would improve (i.e. lower test error on the black and white test set), at the cost of increased training   \n275 error (on the colored training set). We compare against Mary et al. (2019), Baharlouei et al. $\\bar { ( 2 0 2 0 ) }$   \n276 and Cho et al. (2020b) as baselines in this experiment.   \n277 The results of this experiment are as illustrated in Fig. 3. The details about the dataset and experimental   \n278 setup is provided in Appendix $\\operatorname { E } .$ In the left panel, we see that with no regularization $\\lambda = 0$ ); the   \n279 test error is around $80 \\%$ . As $\\lambda$ increases, all methods achieve smaller test error while training error   \n280 increases. We also observe that FERMI offers the best test error in this setup. In the right panel,   \n281 we observe that decreasing the batch size results in significantly worse generalization for all three ",
+        "bbox": [
+            143,
+            738,
+            825,
+            835
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/cdd91a2e541695afe351b6eafabfb3e030f4a1aafed01b589cdff1812686dcdf.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            535,
+            97,
+            759,
+            223
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/ecc5305eb0bd24a4d5180fc2d808568ba4769409b85473f5b4c102a0c9053c39.jpg",
+        "image_caption": [
+            "Figure 3: Domain generalization on Color MNIST (Li & Vasconcelos, 2019) using in-process fair algorithms for demographic parity. Left panel: The dashed line is the training error and the solid line is test error. As $\\lambda$ increases, fairness regularization results in a learned representation that is less dependent on color; hence training error increases while test error decreases (all algorithms reach a plateau around $\\lambda = 8$ ). We use $| B | = 5 1 2$ for all baselines. Right panel: We plot test error vs. batch size using an optimized value of $\\lambda$ for each algorithm selected via a validation set. The performance of all baselines drops $10 \\%$ as batch size becomes small whereas FERMI is relatively insensitive to batch size. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            233,
+            93,
+            457,
+            223
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "baselines considered (due to their biased estimators for the regularizer). However, the impact is much less on FERMI. In particular, the performance gap between FERMI and other baselines is more than $20 \\%$ for $| B | = 6 4$ . Finally, FERMI with minibatch size $| B | = 6 4$ still outperforms all other baselines with $| B | > 1 , 0 0 0$ . Finally, notice that the test error achieved by FERMI when $\\sigma = 0$ is $\\sim 3 0 \\%$ , as compared to more than $5 0 \\%$ obtained using REPAIR (Li & Vasconcelos, 2019) for $\\sigma \\leq 0 . 0 5$ . ",
+        "bbox": [
+            171,
+            327,
+            825,
+            397
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Discussion & concluding remarks ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            409,
+            486,
+            425
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we studied three variants of a notion of fairness violation, called exponential Rényi mutual information (ERMI), developed for demographic parity, equalized odds, and equal opportunity notions of fairness. We showed that ERMI is a strong fairness violation divergence providing upper bound guarantees on other popular violation divergences, namely Shannon mutual information, Rényi mutual information (Theorem $\\bigstar \\bigstar \\bigstar$ , Pearson correlation, Rényi correlation (Theorem $\\bigstar$ , and $L _ { q }$ distance violation (Theorem $3 )$ . ",
+        "bbox": [
+            173,
+            430,
+            825,
+            515
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We derived an unbiased estimator for ERMI (Lemma 1), based on which we formulated an empirical objective (FERMI obj.) for solving fair empirical risk minimization with ERMI regularization to balance performance and fairness. We provided a stochastic algorithm for solving FERMI (Algorithm $\\bar { \\bigtriangledown }$ and proved its convergence (Theorem 5); for non-binary sensitive attributes, non-binary target variables, regardless of the batch size. From an experimental perspective, we showed that FERMI leads to better fairness-accuracy tradeoffs than all of the state-of-the-art baselines on a wide variety of binary and non-binary classification tasks (for demographic parity, equalized odds, and equal opportunity). We also showed that these benefits are particularly significant when the number of sensitive attributes grows or the batch size is small. In particular, we observed that FERMI consistently outperforms $\\boxed { \\mathrm { M a r y ~ e t ~ a l . } } \\textcircled { 2 0 1 9 }$ (which tries to empirically solve the same objective Eq. $\\left( \\mathrm { F R M I o b j . } \\right) .$ by up to $20 \\%$ when the batch size is small, suggesting that the unbiasedness of the FERMI estimator is essential in achieving good empirical performance. ",
+        "bbox": [
+            169,
+            520,
+            825,
+            685
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "306 There are several possible explanations for the superior empirical performance of FERMI compared   \n307 to baselines. One possible reason is that the objective function Eq. (FERMI obj.) is easier to optimize   \n308 than the objectives of competing in-processing methods: ERMI is smooth; and in the discrete case, is   \n309 equal to the trace of a matrix (see Theorem $\\textcircled { 7 }$ appendix), which is easy to compute. Contrast this with   \n310 the larger computational overhead of Rényi correlation used by Baharlouei et al. $\\underline { { \\textregistered 2 0 2 0 } }$ , for example,   \n311 which requires finding the second singular value of a matrix. Furthermore, the sample complexity of   \n312 estimating Rényi mutual information of order 2 (and consequently that of ERMI) scales as $\\Theta ( \\sqrt { | { \\cal S } | } )$   \n313 as compared to Shannon mutual information which scales as $\\Theta ( | S | / \\log | S | )$ (Acharya et al., 2014).   \n314 Moreover, the fact that ERMI is a stronger fairness violation seems to imply that FERMI would   \n315 generalize well to other fairness notions, a hypothesis that is supported by our experimental results.   \n316 Together, these facts suggest that ERMI serves as an efficient and easily optimizable proxy for these   \n317 other fairness notions, making Eq. (FERMI obj.) a good surrogate objective to optimize for all three   \n318 notions of fairness considered (demographic parity, equalized odds, and equal opportunity). We leave   \n319 it as future work to rigorously understand which of these (or other) factors are most responsible for   \n320 the favorable performance tradeoffs observed from FERMI. ",
+        "bbox": [
+            138,
+            693,
+            826,
+            901
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References   \nAcharya, J., Orlitsky, A., Suresh, A. T., and Tyagi, H. The complexity of estimating Rényi entropy. arXiv:1408.1000v1, 2014.   \nAghaei, S., Azizi, M. J., and Vayanos, P. Learning optimal and fair decision trees for nondiscriminative decision-making. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 1418–1426, 2019.   \nAngwin, J., Larson, J., Mattu, S., and Kirchner, L. Machine bias. ProPublica, 2016.   \nBaharlouei, S., Nouiehed, M., Beirami, A., and Razaviyayn, M. Rényi fair inference. In ICLR, 2020.   \nBechavod, Y. and Ligett, K. Penalizing unfairness in binary classification. arXiv preprint arXiv:1707.00044, 2017.   \nBechavod, Y., Ligett, K., Roth, A., Waggoner, B., and Wu, Z. S. Equal opportunity in online classification with partial feedback. arXiv preprint arXiv:1902.02242, 2019.   \nBerk, R., Heidari, H., Jabbari, S., Joseph, M., Kearns, M., Morgenstern, J., Neel, S., and Roth, A. A convex framework for fair regression. arXiv preprint arXiv:1706.02409, 2017.   \nBolukbasi, T., Chang, K.-W., Zou, J. Y., Saligrama, V., and Kalai, A. T. Man is to computer programmer as woman is to homemaker? debiasing word embeddings. In Advances in neural information processing systems, pp. 4349–4357, 2016.   \nCalmon, F., Makhdoumi, A., Médard, M., Varia, M., Christiansen, M., and Duffy, K. R. Principal inertia components and applications. IEEE Transactions on Information Theory, 63(8):5011–5038, 2017a.   \nCalmon, F., Wei, D., Vinzamuri, B., Ramamurthy, K. N., and Varshney, K. R. Optimized preprocessing for discrimination prevention. In Advances in Neural Information Processing Systems, pp. 3992–4001, 2017b.   \nCho, J., Hwang, G., and Suh, C. A fair classifier using mutual information. In 2020 IEEE International Symposium on Information Theory (ISIT), pp. 2521–2526. IEEE, 2020a.   \nCho, J., Hwang, G., and Suh, C. A fair classifier using kernel density estimation. In Larochelle, H., Ranzato, M., Hadsell, R., Balcan, M., and Lin, H. (eds.), Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020b.   \nChzhen, E. and Schreuder, N. A minimax framework for quantifying risk-fairness trade-off in regression. arXiv preprint arXiv:2007.14265, 2020.   \nCover, T. M. and Thomas, J. A. Information theory and statistics. Elements of Information Theory, 1 (1):279–335, 1991.   \nCsiszár, I. and Shields, P. C. Information theory and statistics: A tutorial. Now Publishers Inc, 2004.   \nDatta, A., Tschantz, M. C., and Datta, A. Automated experiments on ad privacy settings. Proceedings on privacy enhancing technologies, 2015(1):92–112, 2015.   \nDembo, A. and Zeitouni, O. Large deviations techniques and applications. Springer Science & Business Media, 2009.   \nDonini, M., Oneto, L., Ben-David, S., Shawe-Taylor, J. S., and Pontil, M. Empirical risk minimization under fairness constraints. In Advances in Neural Information Processing Systems, pp. 2791–2801, 2018.   \nDwork, C., Hardt, M., Pitassi, T., Reingold, O., and Zemel, R. Fairness through awareness. In Proceedings of the 3rd innovations in theoretical computer science conference, pp. 214–226, 2012.   \nFeldman, M., Friedler, S. A., Moeller, J., Scheidegger, C., and Venkatasubramanian, S. Certifying and removing disparate impact. In proceedings of the 21th ACM SIGKDD international conference on knowledge discovery and data mining, pp. 259–268, 2015.   \n367 Fish, B., Kun, J., and Lelkes, Á. D. A confidence-based approach for balancing fairness and accuracy. In Proceedings of the 2016 SIAM International Conference on Data Mining, pp. 144–152. SIAM, 2016.   \n370 Gebelein, H. Das statistische problem der korrelation als variations-und eigenwertproblem und sein zusammenhang mit der ausgleichsrechnung. ZAMM-Journal of Applied Mathematics and Mechanics/Zeitschrift für Angewandte Mathematik und Mechanik, 21(6):364–379, 1941. Grari, V., Ruf, B., Lamprier, S., and Detyniecki, M. Fairness-aware neural Réyni minimization for continuous features. arXiv preprint arXiv:1911.04929, 2019. Grari, V., Hajouji, O. E., Lamprier, S., and Detyniecki, M. Learning unbiased representations via Rényi minimization. arXiv preprint arXiv:2009.03183, 2020. Hardt, M., Price, E., and Srebro, N. Equality of opportunity in supervised learning. In Advances in neural information processing systems, pp. 3315–3323, 2016. Hirschfeld, H. O. A connection between correlation and contingency. In Proceedings of the Cambridge Philosophical Society, volume 31, pp. 520–524, 1935. Jiang, R., Pacchiano, A., Stepleton, T., Jiang, H., and Chiappa, S. Wasserstein fair classification. In Uncertainty in Artificial Intelligence, pp. 862–872. PMLR, 2020. Kamiran, F., Calders, T., and Pechenizkiy, M. Discrimination aware decision tree learning. In 2010 IEEE International Conference on Data Mining, pp. 869–874. IEEE, 2010.   \n385 Kamishima, T., Akaho, S., and Sakuma, J. Fairness-aware learning through regularization approach. In 2011 IEEE 11th International Conference on Data Mining Workshops, pp. 643–650. IEEE, 2011.   \n388 Kearns, M., Neel, S., Roth, A., and Wu, Z. S. Preventing fairness gerrymandering: Auditing and learning for subgroup fairness. In International Conference on Machine Learning, pp. 2564–2572, 2018. Kilbertus, N., Rodriguez, M. G., Schölkopf, B., Muandet, K., and Valera, I. Fair decisions despite imperfect predictions. In Chiappa, S. and Calandra, R. (eds.), Proceedings of the Twenty Third International Conference on Artificial Intelligence and Statistics, volume 108 of Proceedings of Machine Learning Research, pp. 277–287. PMLR, 26–28 Aug 2020. Lecun, Y., Bottou, L., Bengio, Y., and Haffner, P. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. doi: 10.1109/5.726791.   \n397 Li, Y. and Vasconcelos, N. Repair: Removing representation bias by dataset resampling. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9572–9581, 2019.   \n400 Lin, T., Jin, C., and Jordan, M. I. On gradient descent ascent for nonconvex-concave minimax problems. arXiv: 1906.00331v6, 2020. Luo, L., Ye, H., and Zhang, T. Stochastic recursive gradient descent ascent for stochastic nonconvexstrongly-concave minimax problems. arXiv: 2001.03724, 2020. Mary, J., Calauzenes, C., and El Karoui, N. Fairness-aware learning for continuous attributes and treatments. In International Conference on Machine Learning, pp. 4382–4391. PMLR, 2019. Pérez-Suay, A., Laparra, V., Mateo-García, G., Muñoz-Marí, J., Gómez-Chova, L., and Camps-Valls, G. Fair kernel learning. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 339–355. Springer, 2017. Pleiss, G., Raghavan, M., Wu, F., Kleinberg, J., and Weinberger, K. Q. On fairness and calibration. In Advances in Neural Information Processing Systems, pp. 5680–5689, 2017.   \n411 Raff, E., Sylvester, J., and Mills, S. Fair forests: Regularized tree induction to minimize model bias. In Proceedings of the 2018 AAAI/ACM Conference on AI, Ethics, and Society, pp. 243–250, 2018. ",
+        "bbox": [
+            163,
+            83,
+            828,
+            919
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            80,
+            828,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "413 Rényi, A. On measures of dependence. Acta Mathematica Academiae Scientiarum Hungarica, 10   \n414 (3-4):441–451, 1959.   \n415 Rényi, A. On measures of entropy and information. In Proceedings of the Fourth Berkeley Symposium   \n416 on Mathematical Statistics and Probability, Volume 1: Contributions to the Theory of Statistics.   \n417 The Regents of the University of California, 1961.   \n418 Rezaei, A., Fathony, R., Memarrast, O., and Ziebart, B. D. Fairness for robust log loss classification.   \n419 In AAAI, pp. 5511–5518, 2020.   \n420 Steinberg, D., Reid, A., O’Callaghan, S., Lattimore, F., McCalman, L., and Caetano, T. Fast fair   \n421 regression via efficient approximations of mutual information. arXiv preprint arXiv:2002.06200,   \n422 2020.   \n423 Sweeney, L. Discrimination in online ad delivery. arXiv preprint arXiv:1301.6822, 2013.   \n424 Taskesen, B., Nguyen, V. A., Kuhn, D., and Blanchet, J. A distributionally robust approach to fair   \n425 classification. arXiv preprint arXiv:2007.09530, 2020.   \n426 Williamson, R. and Menon, A. Fairness risk measures. In International Conference on Machine   \n427 Learning, pp. 6786–6797. PMLR, 2019.   \n428 Witsenhausen, H. S. On sequences of pairs of dependent random variables. SIAM Journal on Applied   \n429 Mathematics, 28(1):100–113, 1975.   \n430 Woodworth, B., Gunasekar, S., Ohannessian, M. I., and Srebro, N. Learning non-discriminatory   \n431 predictors. arXiv preprint arXiv:1702.06081, 2017.   \n432 Zafar, M. B., Valera, I., Rogriguez, M. G., and Gummadi, K. P. Fairness constraints: Mechanisms for   \n433 fair classification. In Artificial Intelligence and Statistics, pp. 962–970. PMLR, 2017.   \n434 Zemel, R., Wu, Y., Swersky, K., Pitassi, T., and Dwork, C. Learning fair representations. In   \n435 International Conference on Machine Learning, pp. 325–333, 2013.   \n436 Zhang, B. H., Lemoine, B., and Mitchell, M. Mitigating unwanted biases with adversarial learning.   \n437 In Proceedings of the 2018 AAAI/ACM Conference on AI, Ethics, and Society, pp. 335–340, 2018. ",
+        "bbox": [
+            137,
+            88,
+            828,
+            553
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            131
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes]   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            227
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            231,
+            493,
+            244
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] ",
+        "bbox": [
+            236,
+            248,
+            735,
+            280
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            285,
+            393,
+            299
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [No] ",
+        "bbox": [
+            238,
+            303,
+            826,
+            421
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            215,
+            426,
+            823,
+            440
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No] ",
+        "bbox": [
+            238,
+            444,
+            823,
+            551
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            556,
+            705,
+            570
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            574,
+            825,
+            665
+        ],
+        "page_idx": 12
+    }
+]